Add new examples

returnvalue · returnvalue · commit bbd44852d9f1 · 2022-02-21T13:36:38.000-05:00
diff --git a/README.md b/README.md
@@ -44,4 +44,9 @@ files, and the full tutorial for each collection of code is available below. 
 37. [Python Datetime Module Tutorial](https://vegibit.com/python-datetime-module-tutorial/)
 38. [Python os Module Tutorial](https://vegibit.com/python-os-module-tutorial/)
 39. [What Is A Python Decorator](https://vegibit.com/what-is-a-python-decorator/)
-40. [What Is if \_\_name\_\_ == "\_\_main\_\_": main()](https://vegibit.com/python-if-__name__-__main__-main/)
+40. [What Is if \_\_name\_\_ == "\_\_main\_\_": main()](https://vegibit.com/python-if-__name__-__main__-main/)
+41. [What Is A Pandas Dataframe](https://vegibit.com/what-is-a-pandas-dataframe/)
+42. [Python Stack Data Structure](https://vegibit.com/python-stack-data-structure/)
+43. [Python Queue Example](https://vegibit.com/python-queue-example/)
+44. [Python Deque Vs Queue](https://vegibit.com/python-deque-vs-queue/)
+45. [Python Binary Search Tree](https://vegibit.com/python-binary-search-tree/)
diff --git a/deque.py b/deque.py
@@ -0,0 +1,36 @@
+class Deque:
+
+    def __init__(self):
+        self.items = []
+
+    def add_front(self, item):
+        self.items.insert(0, item)
+
+    def add_rear(self, item):
+        self.items.append(item)
+
+    def remove_front(self):
+        if self.items:
+            return self.items.pop(0)
+        return None
+
+    def remove_rear(self):
+        if self.items:
+            return self.items.pop()
+        return None
+
+    def peek_front(self):
+        if self.items:
+            return self.items[0]
+        return None
+
+    def peek_rear(self):
+        if self.items:
+            return self.items[-1]
+        return None
+
+    def size(self):
+        return len(self.items)
+
+    def is_empty(self):
+        return self.items == []
diff --git a/queue.py b/queue.py
@@ -0,0 +1,24 @@
+class Queue:
+    def __init__(self):
+        self.items = []
+
+    def enqueue(self, item):
+        self.items.insert(0, item)
+
+    def dequeue(self):
+        if self.items:
+            return self.items.pop()
+        else:
+            return None
+
+    def size(self):
+        return len(self.items)
+
+    def peek(self):
+        if self.items:
+            return self.items[-1]
+        else:
+            return None
+
+    def is_empty(self):
+        return self.items == []
diff --git a/stack.py b/stack.py
@@ -0,0 +1,24 @@
+class Stack:
+    def __init__(self):
+        self.items = []
+
+    def push(self, item):
+        self.items.append(item)
+
+    def pop(self):
+        if self.items:
+            return self.items.pop()
+        else:
+            return None
+
+    def size(self):
+        return len(self.items)
+
+    def is_empty(self):
+        return self.items == []
+
+    def peek(self):
+        if self.items:
+            return self.items[-1]
+        else:
+            return None
diff --git a/tree.py b/tree.py
@@ -0,0 +1,118 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+    def traversePreorder(self):
+        print(self.data)
+        if self.left:
+            self.left.traversePreorder()
+        if self.right:
+            self.right.traversePreorder()
+
+    def traverseInorder(self):
+        if self.left:
+            self.left.traverseInorder()
+        print(self.data)
+        if self.right:
+            self.right.traverseInorder()
+
+    def traversePostorder(self):
+        if self.left:
+            self.left.traversePostorder()
+        if self.right:
+            self.right.traversePostorder()
+        print(self.data)
+
+    def search(self, target):
+        if self.data == target:
+            print("Found it!")
+            return self
+
+        if self.left and self.data > target:
+            return self.left.search(target)
+
+        if self.right and self.data < target:
+            return self.right.search(target)
+
+        print("Value is not in tree")
+
+    def getNodesAtDepth(self, depth, nodes=[]):
+        if depth == 0:
+            nodes.append(self.data)
+            return nodes
+
+        if self.left:
+            self.left.getNodesAtDepth(depth - 1, nodes)
+        else:
+            nodes.extend([None] * 2 ** (depth - 1))
+
+        if self.right:
+            self.right.getNodesAtDepth(depth - 1, nodes)
+        else:
+            nodes.extend([None] * 2 ** (depth - 1))
+        return nodes
+
+    def height(self, h=0):
+        leftHeight = self.left.height(h + 1) if self.left else h
+        rightHeight = self.right.height(h + 1) if self.right else h
+        return max(leftHeight, rightHeight)
+
+
+class Tree:
+    def __init__(self, root, name=''):
+        self.root = root
+        self.name = name
+
+    def _nodeToChar(self, n, spacing):
+        if n is None:
+            return '_' + (' ' * spacing)
+        spacing = spacing - len(str(n)) + 1
+        return str(n) + (' ' * spacing)
+
+    def print(self, label=''):
+        print(self.name + ' ' + label)
+        height = self.root.height()
+        spacing = 3
+        width = int((2 ** height - 1) * (spacing + 1) + 1)
+        # Root offset
+        offset = int((width - 1) / 2)
+        for depth in range(0, height + 1):
+            if depth > 0:
+                # print directional lines
+                print(' ' * (offset + 1) + (' ' * (spacing + 2)).join(['/' + (' ' * (spacing - 2)) + '\\'] * (2 ** (depth - 1))))
+            row = self.root.getNodesAtDepth(depth, [])
+            print((' ' * offset) + ''.join([self._nodeToChar(n, spacing) for n in row]))
+            spacing = offset + 1
+            offset = int(offset / 2) - 1
+        print('')
+
+    def traverseInorder(self):
+        self.root.traverseInorder()
+
+    def traversePreorder(self):
+        self.root.traversePreorder()
+
+    def traversePostorder(self):
+        self.root.traversePostorder()
+
+    def search(self, target):
+        return self.root.search(target)
+
+    def getNodesAtDepth(self, depth):
+        return self.root.getNodesAtDepth(depth)
+
+    def height(self):
+        return self.root.height()
+
+
+tree = Tree(Node(20))
+tree.root.left = Node(15)
+tree.root.right = Node(25)
+tree.root.left.left = Node(12)
+tree.root.left.right = Node(16)
+tree.root.right.left = Node(23)
+tree.root.right.right = Node(100)
+
+tree.print()
