updating with main branch

common/bellman–ford.py

@@ -0,0 +1,31 @@
+"""
+First, we use `distance` to track the distance from start to all others.
+For V nodes, it takes at least V-1 iteration to complete the algorithm.
+For every iteration,
+We use every node as the middle point to see if it can "loosen" the path from start to mid to mid's neighbors
+If it can loosen the path, we update the `distance`.
+The time complexity is O(VE)
+"""
+def min_path(G, N, start, end):
+    distance = [float('inf') for _ in xrange(N+1)]
+    distance[start] = 0
+
+    for _ in xrange(N-1):
+        for mid, dis in enumerate(distance):
+            if dis==float('inf'): continue
+            for dis_to_nei, nei in G[mid]:
+                distance[nei] = min(distance[nei], dis+dis_to_nei)
+    return distance[end]
+
+
+G = {
+    0: [(-2, 1), (4, 2)],
+    1: [(5, 2)],
+    2: [(12, 3), (5, 4)],
+    3: [(-8, 4)],
+    4: []
+}
+N = 4 #nodes count
+start = 0
+end = 4
+print min_path(G, N, start, end)

common/binary-search-tree.py

@@ -0,0 +1,97 @@
+class Node(object):
+	def __init__(self, val):
+		self.left = None
+		self.right = None
+		self.val = val
+
+
+class BinarySearchTree(object):
+	def __init__(self, val):
+		self.root = Node(val)
+
+	def insert(self, val):
+		def helper(node, val):
+			if val>node.val:
+				if node.right:
+					helper(node.right, val)
+				else:
+					node.right = Node(val)
+			elif val<node.val:
+				if node.left:
+					helper(node.left, val)
+				else:
+					node.left = Node(val)
+		helper(self.root, val)
+		# self.printTree()
+
+	def search(self, val):
+		def helper(node, val):
+			if node==None:
+				return False
+			elif val==node.val:
+				return True
+			elif val>node.val:
+				return helper(node.right, val)
+			elif val<node.val:
+				return helper(node.left, val)
+
+		print helper(self.root, val)
+		# self.printTree()
+
+	def inOrderPrint(self):
+		def helper(node):
+			if node.left: helper(node.left)
+			print node.val
+			if node.right: helper(node.right)
+		helper(self.root)
+
+	def preOrderPrint(self):
+		def helper(node):
+			print node.val
+			if node.left: helper(node.left)
+			if node.right: helper(node.right)
+		helper(self.root)
+
+	def postOrderPrint(self):
+		def helper(node):
+			if node.left: helper(node.left)
+			if node.right: helper(node.right)
+			print node.val
+		helper(self.root)
+
+tree = BinarySearchTree(4)
+tree.insert(2)
+tree.insert(1)
+tree.insert(3)
+tree.insert(5)
+tree.insert(5)
+tree.insert(7)
+
+tree.inOrderPrint()
+print '====='
+tree.preOrderPrint()
+print '====='
+tree.postOrderPrint()
+print '====='
+
+tree.search(3)
+tree.search(10)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

common/bst-in-order.py

@@ -0,0 +1,15 @@
+def inOrderTraverse(root):
+    stack = []
+    node = root
+
+    while node or stack:
+        while node:
+            stack.append(node)
+            node = node.left
+
+        node = stack.pop()
+
+        #do something
+        print node.val
+
+        node = node.right

common/dijkstra.py

@@ -0,0 +1,87 @@
+import heapq
+
+"""
+If we only want to find the shortest distance to the end and not all the nodes's shortest distance
+The ending condition will be when `end` pop out from the `pq`.
+And the path would be all the nodes that were popped out.
+"""
+
+#heap implementation
+def min_path(G, start, end):
+	distance = {}
+	pq = []
+	prev = {}
+	path_str = ''
+	visited = set()
+
+	distance[start] = 0
+	heapq.heappush(pq, (0, start))
+
+	while pq:
+		dis_to_mid, mid = heapq.heappop(pq)
+		visited.add(mid)
+
+		for dis, nei in G[mid]:
+			if nei not in distance or distance[nei]>dis_to_mid+dis:
+				distance[nei] = dis_to_mid+dis
+				prev[nei] = mid
+				if nei not in visited:
+					heapq.heappush(pq, (distance[nei], nei))
+
+	curr = end
+	while True:
+		if curr not in prev: break
+		path_str = ' -> '+prev[curr]+path_str
+		curr = prev[curr]
+
+	return path_str+' = '+str(distance[end])
+
+
+
+#normal implementation
+def min_path(G, start, end):
+	distance = {} #shortest distance from start
+	prev = {}
+	path_str = ''
+	visited = set()
+
+	distance[start] = 0
+	while True:
+		#find nearest unvisited node
+		mid = None
+		dis_to_mid = float('inf')
+		for node in distance:
+			if node not in visited and distance[node]<dis_to_mid:
+				mid = node
+				dis_to_mid = distance[node]
+
+		if mid==None: break
+		visited.add(mid)
+
+		#try to use mid to loosen the prev from start to mid's neighbors
+		for dis, nei in G[mid]:
+			if nei not in distance or dis_to_mid+dis<distance[nei]:
+				distance[nei] = dis_to_mid+dis
+				prev[nei] = mid
+
+	curr = end
+	while True:
+		if curr not in prev: break
+		path_str = ' -> '+prev[curr]+path_str
+		curr = prev[curr]
+
+	print path_str+' = '+str(distance[end])
+
+G = {
+	'0': [(1, '1'), (12, '2')],
+	'1': [(9, '2'), (3, '3')],
+	'2': [(5, '4')],
+	'3': [(4, '2'), (13, '4'), (15, '5')],
+	'4': [(4, '5')],
+	'5': []
+}
+
+print min_path(G, '0', '5')
+
+
+

common/heap-sort.py

@@ -0,0 +1,33 @@
+#O(LogN), used when part of the array is already heapified.
+def heapify(A, N, i):
+	largest = i
+	l = i*2+1
+	r = i*2+2
+
+	if l<N and A[l]>A[largest]: largest = l
+	if r<N and A[r]>A[largest]: largest = r
+	if largest!=i:
+		A[largest], A[i] = A[i], A[largest]
+		heapify(A, N, largest)
+
+#O(NLogN)
+def heapSort(A):
+	N = len(A)
+
+	#build max heap, O(NLogN). Can be optimized to the O(N).
+	for i in range(N//2-1, -1, -1):
+		heapify(A, N, i)
+
+	#keep swapping the largest
+	for i in range(N-1, -1, -1):
+		A[0], A[i] = A[i], A[0]
+		heapify(A, i, 0)
+
+
+A = [12, 11, 13, 5, 6, 7]
+heapSort(A)
+print(A)
+
+A = [1, 3, 5, 4, 6, 13, 10, 9, 8, 15, 17]
+heapSort(A)
+print(A)

common/insertion-sort.py

@@ -0,0 +1,19 @@
+def insertionSort(nums):
+	for i in xrange(len(nums)):
+		num = nums[i]
+		j = i-1
+		while j>=0 and num<nums[j]:
+			nums[j+1] = nums[j]
+			j-=1
+		nums[j+1] = num
+	return nums
+
+
+if __name__ == '__main__':
+	test = [21, 4, 1, 3, 9, 20, 25, 6, 21, 14]
+	print insertionSort(test)
+
+"""
+Time Complexity is O(N^2) in average and worst case. O(N) in best case.
+Space Complexity is O(1).
+"""

common/knapsack.py

@@ -0,0 +1,42 @@
+def get_max_value(value, weight, max_weight):
+	N = len(value)
+	K = [[0 for _ in xrange(max_weight+1)] for _ in xrange(N+1)]
+	bag = []
+
+	for i in xrange(N+1):
+		for mw in xrange(max_weight+1):
+			if i==0 or mw==0:
+				K[i][mw] = 0
+				continue
+			w = weight[i-1]
+			v = value[i-1]
+			if w>mw:
+				K[i][mw] = K[i-1][mw]
+			else:
+				K[i][mw] = max(v+K[i-1][mw-w], K[i-1][mw])
+
+	max_value = K[-1][-1]
+
+	w = max_weight
+	i = N
+	while i>0:
+		if K[i][w]-K[i-1][w]>0:
+			bag.append(i-1)
+			w = w - weight[i-1]
+		i = i-1
+
+	print 'bag: ', bag
+	print 'max_value', max_value
+	return max_value
+
+
+value = [60, 100, 120]
+weight = [10, 20, 30]
+max_weight = 50
+get_max_value(value, weight, max_weight)
+
+value = [40, 100, 50, 60]
+weight = [20, 10, 40, 30]
+max_weight = 60
+get_max_value(value, weight, max_weight)
+

common/merge-sort-in-place.py

@@ -0,0 +1,22 @@
+def merge(A, start, mid, end):
+    L, R = A[start:mid], A[mid:end]
+    i = j = 0
+    k = start
+    for l in xrange(k,end):
+        if j>=len(R) or (i<len(L) and L[i]<R[j]):
+            A[l] = L[i]
+            i = i+1
+        else:
+            A[l] = R[j]
+            j = j+1
+
+def mergeSort(A, p, r):
+    if r - p > 1:
+        mid = (p+r)/2
+        mergeSort(A, p, mid)
+        mergeSort(A, mid, r)
+        merge(A, p, mid, r)
+
+A  = [20, 30, 21, 15, 42, 45, 31, 0, 9]
+mergeSort(A, 0, len(A))
+print A