no message

Author: wuduhren

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/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,35 @@
+def heapSort(A):
+	#build max heap
+	def heapify(A, n, i):
+		if i>=n: return
+		l, r = i*2+1, i*2+2
+		left = A[l] if l<n else float('-inf')
+		right = A[r] if r<n else float('-inf')
+
+		if left>A[i] or right>A[i]:
+			if left>right:
+				A[i], A[l] = A[l], A[i]
+				heapify(A, n, l)
+			else:
+				A[i], A[r] = A[r], A[i]
+				heapify(A, n, r)
+
+	n = len(A)
+
+	for i in reversed(xrange(n)):
+		heapify(A, n, i)
+
+	for i in reversed(xrange(1, n)):
+		A[i], A[0] = A[0], A[i]
+		heapify(A, i, 0)
+
+
+
+A = [21, 4, 1, 3, 9, 20, 25, 6, 21, 14]
+heapSort(A)
+print A
+
+"""
+Time Complexity O(NLogN) in best, average, worst case.
+Space Complexity O(1)
+"""

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