update more algorithms

array/longest_increasing_subsequence.py

@@ -0,0 +1,23 @@
+
+
+def longest_increasing_subsequence(sequence):
+    """
+    Dynamic Programming Algorithm for
+    counting the length of longest increasing subsequence
+    type sequence: List[int]
+    """
+    length = len(sequence)
+    counts = [1 for _ in range(length)]
+    for i in range(1, length):
+        for j in range(0, i):
+            if sequence[i] > sequence[j]:
+                counts[i] = max(counts[i], counts[j] + 1)
+                print(counts)
+    return max(counts)
+
+
+sequence = [1, 101, 10, 2, 3, 100, 4, 6, 2]
+print("sequence: ", sequence)
+print("output: ", longest_increasing_subsequence(sequence))
+print("answer: ", 5)
+

sorting/merge_sort.py

@@ -1,5 +1,3 @@
-
-
 def merge_sort(arr):
     """ Merge Sort
         Complexity: O(n log(n))
@@ -36,3 +34,7 @@ def merge(left, right):
         arr.extend(right[right_cursor:])
     return arr
 
+array = [1,5, 7,4,3,2,1,9,0,10,43,64]
+print(array)
+print(merge_sort(array, 0, len(array)-1))
+print(array)

sorting/quick_sort.py

@@ -1,9 +1,6 @@
-array = [1,5, 7,4,3,2,1,9,0,10,43,64]
-
-
 def quick_sort(arr, first, last):
     """ Quicksort
-        Complexity: O(n log(n))
+        Complexity: best O(n) avg O(n log(n)), worst O(N^2)
     """
     if first < last:
         pos = partition(arr, first, last)
@@ -12,14 +9,15 @@ def quick_sort(arr, first, last):
         quick_sort(arr, pos+1, last)
 
 def partition(arr, first, last):
-    pivot = first
+    wall = first
     for pos in xrange(first, last):
-        if arr[pos] < arr[last]:
-            arr[pos], arr[pivot] = arr[pivot], arr[pos]
-            pivot += 1
-    arr[pivot], arr[last] = arr[last], arr[pivot]
-    return pivot
+        if arr[pos] < arr[last]: # last is the pivot
+            arr[pos], arr[wall] = arr[wall], arr[pos]
+            wall += 1
+    arr[wall], arr[last] = arr[last], arr[wall]
+    return wall
 
+array = [1,5, 7,4,3,2,1,9,0,10,43,64]
 print(array)
 print(quick_sort(array, 0, len(array)-1))
 print(array)

string/license_number.py

@@ -0,0 +1,19 @@
+
+def license_number(key, K):
+    res, alnum = [], []
+    for char in key:
+        if char != "-":
+            alnum.append(char)
+    for i, char in enumerate(reversed(alnum)):
+        res.append(char)
+        if (i+1) % K == 0 and i != len(alnum)-1:
+            res.append("-")
+    return "".join(res[::-1])
+
+
+print(license_number("a-bc-dfd-df", 1), 1)
+print(license_number("a-bc-dfd-df", 2), 2)
+print(license_number("a-bc-dfd-df", 3), 3)
+print(license_number("a-bc-dfd-df", 4), 4)
+print(license_number("a-bc-dfd-df", 5), 5)
+

string/reverseWords.py → string/reverse_words.py

@@ -11,3 +11,4 @@ def reverse(array):
 def reverseWords(array):
     reverse(array)
 
+

tree/bintree2list.py

@@ -0,0 +1,49 @@
+class Node():
+    def __init__(self, val = 0):
+        self.val = val
+        self.left = None
+        self.right = None
+
+def bintree2list(root):
+    """
+    type root: root class
+    """
+    if not root:
+        return root
+    root = bintree2list_util(root)
+    while root.left:
+        root = root.left
+    return root
+
+def bintree2list_util(root):
+    if not root:
+        return root
+    if root.left:
+        left = bintree2list_util(root.left)
+        while left.right:
+            left = left.right
+        left.right = root
+        root.left = left
+    if root.right:
+        right = bintree2list_util(root.right)
+        while right.left:
+            right = right.left
+        right.left = root
+        root.right = right
+    return root
+
+def print_tree(root):
+    while root:
+        print(root.val)
+        root = root.right
+
+tree = Node(10)
+tree.left = Node(12)
+tree.right = Node(15)
+tree.left.left  = Node(25)
+tree.left.left.right  = Node(100)
+tree.left.right = Node(30)
+tree.right.left = Node(36)
+
+head = bintree2list(tree)
+print_tree(head)