update LIS and patience sort

Author: wandering007

README.md

@@ -13,8 +13,10 @@ A collection of commonly used algorithms, written in C/C++, java, Python...
 - Search  
     - [K_{th} element selection](https://github.com/wandering007/algorithms/blob/master/kth_element_selection.cpp)
     - [Knuth–Morris–Pratt algorithm](https://github.com/wandering007/algorithms/blob/master/kmp.cpp)  
+    - [Longest increasing subsequence](https://github.com/wandering007/algorithms/blob/master/longest_increasing_subsequence.py)
 - Sorting  
     - [Heap sort](https://github.com/wandering007/algorithms/blob/master/sorting/heap_sort.cpp)
+    - [Patience sort](https://github.com/wandering007/algorithms/blob/master/sorting/patience_sort.cpp)
 - Computational Geometry  
     - [Convex hull](https://github.com/wandering007/algorithms/blob/master/convex_hull.cpp)  
 - Number Theory  

Longest_increasing_subsequence.py longest_increasing_subsequence.py

@@ -8,12 +8,12 @@ def longest_increasing_subsequence(X):
     M = [0] * (N + 1)
     L = 0
     for i in range(N):
-    # Binary search for the largest positive j <= L
+        # Binary search for the largest positive j <= L
         lo = 1
         hi = L
         while lo <= hi:
-            mid = (lo + hi) // 2
-            if X[ M[mid] ] < X[i]:
+            mid = (lo + hi + 1) // 2
+            if X[M[mid]] < X[i]:
                 lo = mid + 1
             else:
                 hi = mid - 1
@@ -33,4 +33,4 @@ def longest_increasing_subsequence(X):
     for i in range(L - 1, -1, -1):
         S.append(X[k])
         k = P[k]
-    return S[::-1]
+    return S[::-1]

sorting/Patience_sort.cpp

@@ -0,0 +1,60 @@
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+#include <iterator>
+#include <stack>
+#include <vector>
+// reference:
+// https://rosettacode.org/wiki/Sorting_algorithms/Patience_sort#C.2B.2B
+template <class E>
+struct pile_less {
+    bool operator()(const std::stack<E> &pile1,
+                    const std::stack<E> &pile2) const {
+        return pile1.top() < pile2.top();
+    }
+};
+
+template <class E>
+struct pile_greater {
+    bool operator()(const std::stack<E> &pile1,
+                    const std::stack<E> &pile2) const {
+        return pile1.top() > pile2.top();
+    }
+};
+
+template <class Iterator>
+void patienceSort(Iterator first, Iterator last) {
+    typedef typename std::iterator_traits<Iterator>::value_type E;
+    typedef std::stack<E> Pile;
+
+    std::vector<Pile> piles;
+    // sort into piles
+    for (Iterator it = first; it != last; ++it) {
+        E &x = *it;
+        Pile newPile;
+        newPile.push(x);
+        typename std::vector<Pile>::iterator i = std::lower_bound(
+            piles.begin(), piles.end(), newPile, pile_less<E>());
+        if (i != piles.end())
+            i->push(x);
+        else
+            piles.push_back(newPile);
+    }
+
+    // priority queue allows us to merge piles efficiently
+    // we use greater-than comparator for min-heap
+    std::make_heap(piles.begin(), piles.end(), pile_greater<E>());
+    for (Iterator it = first; it != last; ++it) {
+        // moves the smallest to the end
+        std::pop_heap(piles.begin(), piles.end(), pile_greater<E>());
+        Pile &smallPile = piles.back();
+        *it = smallPile.top();
+        smallPile.pop();
+        if (smallPile.empty())
+            piles.pop_back();
+        else
+            // Inserts the element at the position end-1 into the min heap
+            std::push_heap(piles.begin(), piles.end(), pile_greater<E>());
+    }
+    assert(piles.empty());
+}