Graph, heap, binary tree

Author: Scheffer888

Data_Structures_ChatGPT.txt

@@ -0,0 +1 @@
+https://chatgpt.com/share/67538240-b1e0-8007-9b72-3fff133c78f5

data_structures/10_Graph/my_graph.py

@@ -29,9 +29,23 @@ def get_paths(self, start, end, path=[]):
 
         return paths
 
-    def get_shortest_paths(self, ):
-        pass
+    def get_shortest_path(self, start, end, path=[]):
+        path = path + [start]
+
+        if start == end:
+            return path
+
+        if start not in self.graph_dict:
+            return None
 
+        shortest_path = None
+        for node in self.graph_dict[start]:
+            if node not in path:
+                sp = self.get_shortest_path(node, end, path)
+                if sp:
+                    if shortest_path is None or len(sp) < len(shortest_path):
+                        shortest_path = sp
+        return shortest_path
 
 if __name__ == '__main__':
 
@@ -49,11 +63,11 @@ def get_shortest_paths(self, ):
     start = "Mumbai"
     end = "Mumbai"
 
-    print(f"All paths between: {start} and {end}: ",route_graph.get_paths(start,end))
-    #print(f"Shortest path between {start} and {end}: ", route_graph.get_shortest_path(start,end))
+    print(f"\nAll paths between: {start} and {end}:\n" + '\n'.join([' -> '.join(path) for path in route_graph.get_paths(start, end)]))
+    print(f"\nShortest path between {start} and {end}:\n" + ' -> '.join(route_graph.get_shortest_path(start,end)))
 
-    start = "Paris"
-    end = "Toronto"
+    start = "Mumbai"
+    end = "New York"
 
-    print(f"All paths between: {start} and {end}: ",route_graph.get_paths(start,end))
-    #print(f"Shortest path between {start} and {end}: ", route_graph.get_shortest_path(start,end))
+    print(f"\nAll paths between: {start} and {end}:\n" + '\n'.join([' -> '.join(path) for path in route_graph.get_paths(start, end)]))
+    print(f"\nShortest path between {start} and {end}:\n" + ' -> '.join(route_graph.get_shortest_path(start,end)))

data_structures/10_Graph/test.ipynb

@@ -0,0 +1,74 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3\n",
+      "2\n",
+      "0\n",
+      "1\n"
+     ]
+    }
+   ],
+   "source": [
+    "a=6\n",
+    "b=5\n",
+    "print(a//2)\n",
+    "print(b//2)\n",
+    "print(a%2)\n",
+    "print(b%2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[9, 8, 7, 6, 5, 4, 3]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print([i for i in range(10)[:2:-1]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "data_analysis",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

data_structures/11_Heap/heap.py

@@ -0,0 +1,196 @@
+'''
+# Heap
+
+### What is a Heap?
+- A heap is a complete binary tree that satisfies the heap property.
+- The heap property states that the key stored in each node is either greater than or equal to (≥) - for a maxheap - or
+    less than or equal to (≤) - for a min heap - the keys in the node's children, according to some total order.    
+
+### Python Library:
+- Python has a built-in library called heapq from that provides heap data structure. Ex.:
+import heapq
+
+### Time Complexity:
+
+    - insert: O(log n)
+    - get_min: O(1)
+    - extract_min: O(log n)
+    - update: O(log n) if we have the index, O(n) if we don't
+    - build: O(n)
+
+'''
+
+class MinHeap:
+    def __init__(self, arr=None): # Heapifies the array in O(n) time
+        self.heap = []
+        if type(arr) is list:
+            self.heap = arr.copy()
+            for i in range(len(self.heap)//2-1, -1, -1):
+                self._siftdown(i)
+
+    def _siftup(self, i):
+        parent = (i-1)//2
+        while i != 0 and self.heap[i] < self.heap[parent]:
+            self.heap[i], self.heap[parent] = self.heap[parent], self.heap[i]
+            i = parent
+            parent = (i-1)//2
+
+    def _siftdown(self, i):
+        left = 2*i + 1
+        right = 2*i + 2
+        while (left < len(self.heap) and self.heap[i] > self.heap[left]) or (right < len(self.heap) and self.heap[i] > self.heap[right]):
+            smallest = left if (right >= len(self.heap) or self.heap[left] < self.heap[right]) else right
+            self.heap[i], self.heap[smallest] = self.heap[smallest], self.heap[i]
+            i = smallest
+            left = 2*i + 1
+            right = 2*i + 2
+
+    def insert(self, element):
+        self.heap.append(element)
+        self._siftup(len(self.heap)-1)
+
+    def get_min(self):
+        return self.heap[0] if len(self.heap) > 0 else None
+
+    def extract_min(self):
+        if len(self.heap) == 0:
+            return None
+        minval = self.heap[0]
+        self.heap[0], self.heap[-1] = self.heap[-1], self.heap[0]
+        self.heap.pop()
+        self._siftdown(0)
+        return minval
+
+    def update_by_index(self, i, new):
+        old = self.heap[i]
+        self.heap[i] = new
+        if new < old:
+            self._siftup(i)
+        else:
+            self._siftdown(i)
+
+    def update(self, old, new):
+        if old in self.heap:
+            self.update_by_index(self.heap.index(old), new)
+
+class MaxHeap:
+    def __init__(self, arr=None):
+        self.heap = []
+        if type(arr) is list:
+            self.heap = arr.copy()
+            for i in range(len(self.heap))[::-1]:
+                self._siftdown(i)
+
+    def _siftup(self, i):
+        parent = (i-1)//2
+        while i != 0 and self.heap[i] > self.heap[parent]:
+            self.heap[i], self.heap[parent] = self.heap[parent], self.heap[i]
+            i = parent
+            parent = (i-1)//2
+
+    def _siftdown(self, i):
+        left = 2*i + 1
+        right = 2*i + 2
+        while (left < len(self.heap) and self.heap[i] < self.heap[left]) or (right < len(self.heap) and self.heap[i] < self.heap[right]):
+            biggest = left if (right >= len(self.heap) or self.heap[left] > self.heap[right]) else right
+            self.heap[i], self.heap[biggest] = self.heap[biggest], self.heap[i]
+            i = biggest
+            left = 2*i + 1
+            right = 2*i + 2
+
+    def insert(self, element):
+        self.heap.append(element)
+        self._siftup(len(self.heap)-1)
+
+    def get_max(self):
+        return self.heap[0] if len(self.heap) > 0 else None
+
+    def extract_max(self):
+        if len(self.heap) == 0:
+            return None
+        maxval = self.heap[0]
+        self.heap[0], self.heap[-1] = self.heap[-1], self.heap[0]
+        self.heap.pop()
+        self._siftdown(0)
+        return maxval
+
+    def update_by_index(self, i, new):
+        old = self.heap[i]
+        self.heap[i] = new
+        if new > old:
+            self._siftup(i)
+        else:
+            self._siftdown(i)
+
+    def update(self, old, new):
+        if old in self.heap:
+            self.update_by_index(self.heap.index(old), new)
+
+
+def heapsort(arr):
+    heap = MinHeap(arr)
+    return [heap.extract_min() for i in range(len(heap.heap))]
+
+
+class PriorityQueue:
+    def __init__(self):
+        self.queue = MaxHeap()
+
+    def enqueue(self, element): # Time complexity is O(log n)
+        self.queue.insert(element)
+
+    def peek(self): # Time complexity is O(1)
+        return self.queue.get_max()
+
+    def dequeue(self, element): # Time complexity is O(log n)
+        return self.queue.extract_max()
+
+    def is_empty(self): # Time complexity is O(1)
+        return len(self.queue.heap) == 0
+
+    def change_priority_by_index(self, i, new): # Time complexity is O(log n) if we have the index
+        self.queue.update_by_index(i, new)
+
+    def change_priority(self, old, new): # Time complexity is O(n) if we don't have the index
+        self.queue.update(old, new)
+
+import heapq
+
+if __name__ == '__main__':
+    arr = [-4, 3, 1, 0, 2, 5, 10, 8, 12, 9]
+
+    # Using the custom MinHeap class
+    minheap = MinHeap(arr)
+    print('Heapmin using the custom MinHeap class:\n', minheap.heap)
+    minn = minheap.extract_min()
+    print('Min value', minn)
+    
+    print()
+    # Using the built-in heapq library
+    arr2 = arr.copy()
+    heapq.heapify(arr2)
+    print('Heapmin using heapq:\n', arr2)
+    minnim = heapq.heappop(arr2)
+    print('Min value: ', minnim)
+    sorted_arr = [heapq.heappop(arr2) for i in range(len(arr2))]
+    print('Sorted array using heapify: ', sorted_arr)
+
+    print()
+    # Using the custom MaxHeap class
+    maxheap = MaxHeap(arr)
+    print('Heapmax using the custom MaxHeap class:\n', maxheap.heap)
+    maxn = maxheap.extract_max()
+    print('Max value: ', maxn)
+
+    print()
+    # Using the built-in heapq library
+    arr3 = [-x for x in arr]
+    heapq.heapify(arr3)
+    print('Heapmax with neg sign using heapq:\n', arr3)
+    maxn = -heapq.heappop(arr3)
+    print('Max value: ', maxn)
+    sorted_arr = [-heapq.heappop(arr3) for i in range(len(arr3))]
+
+
+
+

data_structures/6_Queue/binary_numbers_exercise.py

@@ -1,7 +1,7 @@
 
 from collections import deque
 
-class Queue:
+class dQueue:
     def __init__(self):
         self.buffer = deque()
 
@@ -27,7 +27,7 @@ def size(self):
 
 
 def print_binary(end):
-    queue = Queue()
+    queue = dQueue()
     queue.enqueue('1')
 
     for i in range(end):
@@ -36,10 +36,23 @@ def print_binary(end):
 
         queue.enqueue(binary_number + '0')
         queue.enqueue(binary_number + '1')
-    
 
+# Using queue python library
+from queue import Queue
+def print_binary_2(end):
+    queue = Queue()
+    queue.put('1')
+
+    for i in range(end):
+        binary_number = queue.get()
+        print('   ' + binary_number)
+
+        queue.put(binary_number + '0')
+        queue.put(binary_number + '1')
 
 
 if __name__ == '__main__':
 
-    print_binary(12)
+    print_binary(12)
+    print()
+    print_binary_2(12)

data_structures/8_Binary_Tree_1/binary_tree_part_1_exercise.py

@@ -83,7 +83,7 @@ def find_max(self):
     def find_min(self):
         if self.left is None:
             return self.data
-        return self.left.find_max()
+        return self.left.find_min()
 
     def calculate_sum(self):
         return sum(self.in_order_traversal())

data_structures/8_Binary_Tree_1/binary_tree_terms.ipynb

@@ -12,8 +12,10 @@
     "- **Parent**: A node that has one or more child nodes.\n",
     "- **Child**: A node that has a parent node.\n",
     "- **Leaf**: A node that has no children.\n",
-    "- **Height**: The number of edges on the longest path between the root and a leaf.\n",
+    "- **Height of a tree**: The number of edges on the longest path between the root and a leaf.\n",
     "    - Height of an empty tree is -1.\n",
+    "- **Depth of a node**: The number of edges on the path between the root and the node.\n",
+    "    - Depth of the root is 0.\n",
     "\n",
     "- **Complete Binary Tree**: A binary tree in which every level, except possibly the last, is completely filled, and all nodes are as far left as possible.\n",
     "- **Perfect Binary Tree**: A binary tree in which all interior nodes have two children and all leaves have the same depth.\n",
@@ -25,6 +27,7 @@
     "\n",
     "### Properties\n",
     "\n",
+    "\n",
     "- The maximum number of nodes at level $l$ of a binary tree is $2^l$.\n",
     "- The maximum number of nodes in a binary tree of height $h$ is $2^{h+1}-1$.\n",
     "- In a binary tree with $n$ nodes:\n",