Data structures examples in Python

Author: Hemant-Jain-Author

Algorithms/DFS.py

@@ -0,0 +1,15 @@
+def DFS(head):
+    curr = head
+    count = 0;
+    while (curr !=  None & curr.visited == False):
+        count += 1
+        if (curr.lChild != None & curr.lChild.visited == False):
+            curr= curr.lChild
+        elif (curr.rChild != None & curr.rChild.visited == False):
+            curr= curr.rChild;
+        else:
+            print (curr.value)
+            curr.visited = 1;
+            curr = head;
+
+    print("count is : ", count)

Algorithms/Fibo.py

@@ -0,0 +1,23 @@
+class Prime(object):  
+    @classmethod
+    def main(cls, args):
+        print(cls.isPrime(50))
+        print(cls.isPrime(47))
+    
+    @classmethod
+    def isPrime(self, n):
+        if( n > 1):
+            answer = True
+        else:
+            answer = False
+        i = 2
+        while(i*i <= n):
+            if(n%i == 0):
+                answer = False
+                break
+            i += 1
+        return answer     
+
+if __name__ == '__main__':
+    import sys
+    Prime.main(sys.argv)

Algorithms/NQueen.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+
+class NQueen(object):
+    @classmethod
+    def printArr(cls, Q, n):
+        i = 0
+        while i < n:
+            print(Q[i])
+            i += 1
+        print("")
+
+    @classmethod
+    def Feasible(cls, Q, k):
+        i = 0
+        while i < k:
+            if Q[k] == Q[i] or abs(Q[i] - Q[k]) == abs(i - k):
+                return False
+            i += 1
+        return True
+
+    @classmethod
+    def NQueens(cls, Q, k, n):
+        if k == n:
+            cls.printArr(Q, n)
+            return
+        i = 0
+        while i < n:
+            Q[k] = i
+            if cls.Feasible(Q, k):
+                cls.NQueens(Q, k + 1, n)
+            i += 1
+
+
+    @classmethod
+    def main(cls, args):
+        Q = [0] * 8
+        cls.NQueens(Q, 0, 8)
+        
+if __name__ == '__main__':
+    import sys
+    NQueen.main(sys.argv)

Algorithms/Prime.py

@@ -0,0 +1,45 @@
+class Fibo(object):
+    
+    @classmethod
+    def main(cls, args):
+        print(cls.fibonacci(50))
+        print(cls.fibonacci2(50))
+
+    @classmethod
+    def fibonacci2(cls, n):
+        if n <= 1:
+            return n
+        return cls.fibonacci(n - 1) + cls.fibonacci(n - 2)
+    
+    @classmethod
+    def fibonacci(cls, n):
+        first = 0
+        second = 1
+        if (n == 0):
+            return first;
+        elif (n == 1):
+            return second;
+        i = 2
+        while(i <= n):
+            temp = first + second
+            first = second
+            second = temp
+            i += 1
+        return temp
+    
+    def isPrime(self, n):
+        if( n > 1):
+            answer = True
+        else:
+            answer = False
+        i = 2
+        while(i*i <= n):
+            if(n%i == 0):
+                answer = True;
+                break;
+            i += 1
+        return answer     
+
+if __name__ == '__main__':
+    import sys
+    Fibo.main(sys.argv)

Algorithms/TOH.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+""" generated source for module TOH """
+
+class TOH(object):
+    """ generated source for class TOH """
+    
+    @classmethod
+    def main(cls, args):
+        """ generated source for method main """
+
+        cls.TowersOfHanoi(3)
+
+    @classmethod
+    def TOHUtil(cls, num, source, dest, temp):
+        """ generated source for method TOHUtil """
+        if num < 1:
+            return
+        cls.TOHUtil(num - 1, source, temp, dest)
+        print("Move disk" , num , "from peg" , source , "to peg" , dest)
+        cls.TOHUtil(num - 1, temp, dest, source)
+
+    @classmethod
+    def TowersOfHanoi(cls, num):
+        """ generated source for method TowersOfHanoi """
+        print("The sequence of moves involved in the Tower of Hanoi are :")
+        cls.TOHUtil(num, 'A', 'C', 'B')
+
+
+if __name__ == '__main__':
+    import sys
+    TOH.main(sys.argv)

Collections/Counter.py

@@ -0,0 +1,23 @@
+from collections import Counter
+
+class MyClass:
+ 
+    @classmethod
+    def main(cls, args):
+        """ generated source for method main """
+        seq = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
+        mycounter = Counter(seq)
+        print mycounter
+        print mycounter.get(3)
+        print mycounter.has_key(3)
+        mycounter.pop(4)
+        print mycounter
+        print 4 in mycounter
+        mycounter[5] += 1
+        mycounter[5] += 1
+        print mycounter
+
+
+if __name__ == '__main__':
+    import sys
+    MyClass.main(sys.argv)

Collections/Dictionary.py

@@ -0,0 +1,28 @@
+from collections import OrderedDict
+
+class MyClass: 
+    @classmethod
+    def main(cls, args):
+        """ generated source for method main """
+        a = {}
+        a["apple"] = 40
+        a["banana"] = 10
+        a["mango"] = 20
+        print a
+        print a["mango"]
+        print a.get("mango")
+        print "apple" in a
+        
+        b = OrderedDict()
+        b["apple"] = 40
+        b["banana"] = 10
+        b["mango"] = 20
+        print b
+        print b["mango"]
+        print b.get("mango")
+        print "banana" in b
+        
+
+if __name__ == '__main__':
+    import sys
+    MyClass.main(sys.argv)

Collections/Heap.py

@@ -0,0 +1,22 @@
+import heapq
+
+class MyClass:     
+    @classmethod
+    def main(cls, args):
+        """ generated source for method main """
+        myheap = [19,1,18]              # creates heap from list.
+        heapq.heapify(myheap)
+        print myheap
+        heapq.heappush(myheap, 5)       # pushes a new item on the heap
+        heapq.heappush(myheap, 3)
+        heapq.heappush(myheap, 8)
+        heapq.heappush(myheap, 2)
+        print myheap
+        print heapq.heappop(myheap)     # pops the smallest item from the heap
+        print myheap
+        print myheap[0]                 # peek the smallest element of the heap.
+        print len(myheap)    
+
+if __name__ == '__main__':
+    import sys
+    MyClass.main(sys.argv)

Collections/List.py

@@ -0,0 +1,24 @@
+class MyClass:     
+    @classmethod
+    def main(cls, args):
+        """ generated source for method main """
+        a = []
+        a.append(5)
+        a.append(4)
+        a.append(2)
+        a.append(40)
+        print a
+        print a + a
+        print len(a)
+        a.remove(4)
+        print a
+        print a.pop()
+        a.sort()
+        print a
+        a.reverse()
+        print a
+
+
+if __name__ == '__main__':
+    import sys
+    MyClass.main(sys.argv)

Collections/Queue.py

@@ -0,0 +1,20 @@
+from collections import deque
+
+class MyClass:
+    @classmethod
+    def main(cls, args):
+        """ generated source for method main """
+        a = deque([])
+        a.append(5)
+        a.append(4)
+        a.append(3)
+        a.append(2)
+        a.append(1)
+        a.append(0)
+        print a
+        print a.popleft()
+        print a
+
+if __name__ == '__main__':
+    import sys
+    MyClass.main(sys.argv)

Collections/Set.py

@@ -0,0 +1,18 @@
+class MyClass:
+    @classmethod
+    def main(cls, args):
+        """ generated source for method main """
+        a = set()
+        a.add(5)
+        a.add(4)
+        a.add(2)
+        a.add(1)
+        a.add(5)
+        print a
+        print (4 in a) 
+        a.remove(4)
+        print a    
+
+if __name__ == '__main__':
+    import sys
+    MyClass.main(sys.argv)

Collections/Stack.py

@@ -0,0 +1,25 @@
+from collections import Set
+
+class MyClass:
+                 
+    @classmethod
+    def main(cls, args):
+        """ generated source for method main """
+        a = set()
+        a.add(5)
+        a.add(5)
+        a.add(4)
+        a.add(2)
+        a.add(5)
+        print a
+        print len(a)
+        a.remove(4)
+        print a
+        a.add(8)
+        print a.pop()
+        print a
+        print (5 in a)
+
+if __name__ == '__main__':
+    import sys
+    MyClass.main(sys.argv)