新增5题，LRU Cache, Insertion Sort List, Sort List,Max Points on a Line,Evaluate Reverse Polish Notation

Author: soulmachine

C++/LeetCodet题解(C++版).pdf

@@ -1136,6 +1136,108 @@ \subsubsection{代码}
 \end{Code}
 
 
+\subsubsection{相关题目}
+\begindot
+\item 无
+\myenddot
+
+
+\section{Max Points on a Line} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\label{sec:Max-Points-on-a-Line}
+
+
+\subsubsection{描述}
+Given $n$ points on a 2D plane, find the maximum number of points that lie on the same straight line.
+
+
+\subsubsection{分析}
+暴力枚举法。两点决定一条直线，$n$个点两两组合，可以得到$\dfrac{1}{2}n(n+1)$条直线，对每一条直线，判断$n$个点是否在该直线上，从而可以得到这条直线上的点的个数，选择最大的那条直线返回。复杂度$O(n^3)$。
+
+上面的暴力枚举法以“边”为中心，再看另一种暴力枚举法，以每个“点”为中心，然后遍历剩余点，找到所有的斜率，如果斜率相同，那么一定共线对每个点，用一个哈希表，key为斜率，value为该直线上的点数，计算出哈希表后，取最大值，并更新全局最大值，最后就是结果。时间复杂度$O(n^2)$，空间复杂度$O(n)$。
+
+
+\subsubsection{以边为中心}
+\begin{Code}
+// LeetCode, Max Points on a Line
+// 暴力枚举法，以边为中心，时间复杂度O(n^3)，空间复杂度O(1)
+class Solution {
+public:
+    int maxPoints(vector<Point> &points) {
+        if (points.size() < 3) return points.size();
+        int result = 0;
+
+        for (int i = 0; i < points.size() - 1; i++) {
+            for (int j = i + 1; j < points.size(); j++) {
+                int sign = 0;
+                int a, b, c;
+                if (points[i].x == points[j].x) sign = 1;
+                else {
+                    a = points[j].x - points[i].x;
+                    b = points[j].y - points[i].y;
+                    c = a * points[i].y - b * points[i].x;
+                }
+                int count = 0;
+                for (int k = 0; k < points.size(); k++) {
+                    if ((0 == sign && a * points[k].y == c +  b * points[k].x) || 
+                        (1 == sign&&points[k].x == points[j].x)) 
+                        count++;
+                }
+                if (count > result) result = count;
+            }
+        }
+        return result;
+    }
+};
+\end{Code}
+
+
+\subsubsection{以点为中心}
+\begin{Code}
+// LeetCode, Max Points on a Line
+// 暴力枚举，以点为中心，时间复杂度O(n^2)，空间复杂度O(n)
+class Solution {
+public:
+    int maxPoints(vector<Point> &points) {
+        if (points.size() < 3) return points.size();
+        int result = 0;
+
+        unordered_map<double, int> slope_count;
+        for (int i = 0; i < points.size()-1; i++) {
+            slope_count.clear();
+            int samePointNum = 0; // 与i重合的点
+            int point_max = 1;    // 和i共线的最大点数
+
+            for (int j = i + 1; j < points.size(); j++) {
+                double slope; // 斜率
+                if (points[i].x == points[j].x) {
+                    slope = std::numeric_limits<double>::infinity();
+                    if (points[i].y == points[j].y) {
+                        ++ samePointNum;
+                        continue;
+                    }
+                } else {
+                    slope = 1.0 * (points[i].y - points[j].y) / 
+                        (points[i].x - points[j].x);
+                }
+
+                int count = 0;
+                if (slope_count.find(slope) != slope_count.end())
+                    count = ++slope_count[slope];
+                else {
+                    count = 2;
+                    slope_count[slope] = 2;
+                }
+
+                if (point_max < count) point_max = count;
+            }
+            result = max(result, point_max + samePointNum);
+        }
+        return result;
+    }
+};
+\end{Code}
+
+
 \subsubsection{相关题目}
 \begindot
 \item 无

C++/chapImplement.tex

@@ -2664,3 +2664,86 @@ \subsubsection{相关题目}
 \begindot
 \item 无
 \myenddot
+
+
+\subsection{LRU Cache}
+\label{sec:LRU-Cachet}
+
+
+\subsubsection{描述}
+Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.
+
+\fn{get(key)} - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
+
+\fn{set(key, value)} - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.
+
+
+\subsubsection{分析}
+为了使查找、插入和删除都有较高的性能，我们使用一个双向链表(\fn{std::list})和一个哈希表(\fn{std::unordered_map})，因为：
+\begin{itemize}
+\item{哈希表保存每个节点的地址，可以基本保证在$O(1)$时间内查找节点}
+\item{双向链表插入和删除效率高，单向链表插入和删除时，还要查找节点的前驱节点}
+\end{itemize}
+
+具体实现细节：
+\begin{itemize}
+\item{越靠近链表头部，表示节点上次访问距离现在时间最短，尾部的节点表示最近访问最少}
+\item{访问节点时，如果节点存在，把该节点交换到链表头部，同时更新hash表中该节点的地址}
+\item{插入节点时，如果cache的size达到了上限capacity，则删除尾部节点，同时要在hash表中删除对应的项；新节点插入链表头部}              
+\end{itemize}
+
+
+\subsubsection{代码}
+\begin{Code}
+// LeetCode, LRU Cache
+// 时间复杂度O(logn)，空间复杂度O(n)
+class LRUCache{
+private:
+    struct CacheNode {
+        int key;
+        int value;
+        CacheNode(int k, int v) :key(k), value(v){}
+    };
+public:
+    LRUCache(int capacity) {
+        this->capacity = capacity;
+    }
+
+    int get(int key) {
+        if (cacheMap.find(key) == cacheMap.end()) return -1;
+        
+        // 把当前访问的节点移到链表头部，并且更新map中该节点的地址
+        cacheList.splice(cacheList.begin(), cacheList, cacheMap[key]); 
+        cacheMap[key] = cacheList.begin();
+        return cacheMap[key]->value;
+    }
+
+    void set(int key, int value) {
+        if (cacheMap.find(key) == cacheMap.end()) {
+            if (cacheList.size() == capacity) { //删除链表尾部节点（最少访问的节点）
+                cacheMap.erase(cacheList.back().key);
+                cacheList.pop_back();
+            }
+            // 插入新节点到链表头部, 并且在map中增加该节点
+            cacheList.push_front(CacheNode(key, value));
+            cacheMap[key] = cacheList.begin();
+        } else {
+            //更新节点的值，把当前访问的节点移到链表头部,并且更新map中该节点的地址
+            cacheMap[key]->value = value;
+            cacheList.splice(cacheList.begin(), cacheList, cacheMap[key]);
+            cacheMap[key] = cacheList.begin();
+        }
+    }
+private:
+    list<CacheNode> cacheList;
+    unordered_map<int, list<CacheNode>::iterator> cacheMap;
+    int capacity;
+};
+\end{Code}
+
+
+\subsubsection{相关题目}
+\begindot
+\item 无
+\myenddot
+

C++/chapLinearList.tex

@@ -140,6 +140,118 @@ \subsubsection{相关题目}
 \myenddot
 
 
+\section{Insertion Sort List} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\label{sec:Insertion-Sort-List}
+
+
+\subsubsection{描述}
+Sort a linked list using insertion sort.
+
+
+\subsubsection{分析}
+无
+
+
+\subsubsection{代码}
+\begin{Code}
+// LeetCode, Insertion Sort List
+// 时间复杂度O(n^2)，空间复杂度O(1)
+class Solution {
+public:
+    ListNode *insertionSortList(ListNode *head) {
+        ListNode dummy(INT_MIN);
+        //dummy.next = head;
+
+        for (ListNode *cur = head; cur != nullptr;) {
+            auto pos = findInsertPos(&dummy, cur->val);
+            ListNode *tmp = cur->next;
+            cur->next = pos->next;
+            pos->next = cur;
+            cur = tmp;
+        }
+        return dummy.next;
+    }
+
+    ListNode* findInsertPos(ListNode *head, int x) {
+        ListNode *pre = nullptr;
+        for (ListNode *cur = head; cur != nullptr && cur->val <= x;
+            pre = cur, cur = cur->next)
+            ;
+        return pre;
+    }
+};
+\end{Code}
+
+
+\subsubsection{相关题目}
+\begindot
+\item Sort List, 见 \S \ref{sec:Sort-List}
+\myenddot
+
+
+\section{Sort List} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\label{sec:Sort-List}
+
+
+\subsubsection{描述}
+Sort a linked list in $O(n log n)$ time using constant space complexity.
+
+
+\subsubsection{分析}
+常数空间且$O(nlogn)$，单链表适合用归并排序，双向链表适合用快速排序。本题可以复用 "Merge Two Sorted Lists" 的代码。
+
+
+\subsubsection{代码}
+\begin{Code}
+// LeetCode, Sort List
+// 归并排序，时间复杂度O(nlogn)，空间复杂度O(1)
+class Solution {
+public:
+    ListNode *sortList(ListNode *head) {
+        if (head == NULL || head->next == NULL)return head;
+
+        // 快慢指针找到中间节点
+        ListNode *fast = head, *slow = head;
+        while (fast->next != NULL && fast->next->next != NULL) {
+            fast = fast->next->next;
+            slow = slow->next;
+        }
+        // 断开
+        fast = slow;
+        slow = slow->next;
+        fast->next = NULL;
+
+        ListNode *l1 = sortList(head);  // 前半段排序
+        ListNode *l2 = sortList(slow);  // 后半段排序
+        return mergeTwoLists(l1, l2);
+    }
+
+    // Merge Two Sorted Lists
+    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
+        ListNode dummy(-1);
+        for (ListNode* p = &dummy; l1 != nullptr || l2 != nullptr; p = p->next) {
+            int val1 = l1 == nullptr ? INT_MAX : l1->val;
+            int val2 = l2 == nullptr ? INT_MAX : l2->val;
+            if (val1 <= val2) {
+                p->next = l1;
+                l1 = l1->next;
+            } else {
+                p->next = l2;
+                l2 = l2->next;
+            }
+        }
+        return dummy.next;
+    }
+};
+\end{Code}
+
+
+\subsubsection{相关题目}
+\begindot
+\item Insertion Sort List，见 \S \ref{sec:Insertion-Sort-List}
+\myenddot
+
+
 \section{First Missing Positive} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \label{sec:first-missing-positive}