added demo modules

Signed-off-by: ABHIJIT SINHA <[email protected]>

Author: greyshell

core_concepts/demo_modules/priority_queue/demo_PriorityQueue.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+
+# author: greyshell
+# description: demo how to use PriorityQue
+
+from queue import PriorityQueue
+
+
+class MyHeap(PriorityQueue):
+
+    def __init__(self):
+        super(MyHeap, self).__init__()
+
+    def __lt__(self, other):
+        # compare based on weight
+        return self.key > other.key
+
+
+def main():
+    min_heap = PriorityQueue()
+    # push an item
+    min_heap.put(2, 'code')
+    min_heap.put(1, 'eat')
+    min_heap.put(0, 'bat')
+
+    # peek
+    print(min_heap)
+    # pop the min item
+    print(min_heap.get())
+
+
+if __name__ == '__main__':
+    main()

core_concepts/demo_modules/priority_queue/demo_heapq.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+
+# author: greyshell
+# description: demo how to use heapq library
+
+import heapq
+
+
+class MaxHeapNode(object):
+    def __init__(self, key):
+        self.key = key
+
+    def __lt__(self, other):
+        # compare based on val
+        # tweak the comparison logic to build max heap: change less_than_sign to greater_than_sign
+        return self.key > other.key
+
+    def __gt__(self, other):
+        # compare based on val
+        # tweak the comparison logic to build max heap
+        return self.key < other.key
+
+    def __eq__(self, other):
+        return self.key == other.key
+
+    def __ne__(self, other):
+        return self.key != other.key
+
+    def __str__(self):
+        return str(self.key)
+
+
+def demo_max_heap():
+    print(f"========================================")
+    print(f"demo max heap ")
+    print(f"========================================")
+    # create a max heap that stores an object (key, index, name) and the key is key
+    max_heap = list()
+
+    heapq.heappush(max_heap, MaxHeapNode(17))
+    heapq.heappush(max_heap, MaxHeapNode(1000))
+    heapq.heappush(max_heap, MaxHeapNode(250))
+    heapq.heappush(max_heap, MaxHeapNode(500))
+
+    print(f"max value {max_heap[0]}")
+    node = heapq.heappop(max_heap)
+    print(f"popped item: {node.key}")
+    print(f"max value {max_heap[0]}")
+
+
+class HeapSatelliteNode(object):
+    def __init__(self, name, age):
+        # self.val = val
+        self.name = name
+        self.age = age
+
+    def __lt__(self, other):
+        # compare based on age
+        # tweak the comparison logic to build max heap: change less_than_sign to greater_than_sign
+        # key = age, so compare based on the key
+        return self.age > other.age
+
+    def __eq__(self, other):
+        return self.age == other.age
+
+    def __str__(self):
+        return f"name:{self.name}, age:{self.age}"
+
+
+def demo_max_satellite_heap():
+    print(f"========================================")
+    print(f"demo max satellite heap ")
+    print(f"========================================")
+    # create a max heap that stores an object (key, index, name) and the key is key
+    max_heap = list()
+
+    # compare based on the age
+    heapq.heappush(max_heap, HeapSatelliteNode('asinha', 39))
+    heapq.heappush(max_heap, HeapSatelliteNode('dhaval', 22))
+    heapq.heappush(max_heap, HeapSatelliteNode('ravi', 23))
+
+    print(f"max value {max_heap[0]}")
+    node = heapq.heappop(max_heap)
+    print(f"popped item: {node.name}")
+    print(f"max value {max_heap[0]}")
+
+    print(heapq.heappop(max_heap))
+    print(heapq.heappop(max_heap))
+
+    if max_heap:  # check if the list is empty or not
+        print(heapq.heappop(max_heap))
+
+
+def heap_sort(nums):
+    heapq.heapify(nums)
+    return [heapq.heappop(nums) for _ in range(0, len(nums))]
+
+
+def main():
+    min_heap = [12, 7, 11, 15, 35, 17]
+
+    print(f"========================================")
+    print(f"demo heap sort")
+    print(f"========================================")
+
+    print(f"before heap sort: {min_heap}")
+    r = heap_sort(min_heap)
+    print(f"after heap sort: {r}")
+
+    print(f"========================================")
+    print(f"demo min heap ")
+    print(f"========================================")
+    # build a min heap
+    heapq.heapify(min_heap)  # in-place, in linear time, O(n), Heap elements can be tuples.
+
+    # push an item
+    heapq.heappush(min_heap, 25)  # O(log(n))
+    heapq.heappush(min_heap, 5)  # O(log(n))
+    heapq.heappush(min_heap, 10)  # O(log(n))
+
+    # peek the min item
+    data = min_heap[0]  # O(1)
+
+    # pop an item
+    data = heapq.heappop(min_heap)  # O(log(n))
+    print(f"popped item: {data}")
+    print(f"current heap : {min_heap}")
+
+    # when we need to make the heap size constant, we can use heappushpop() and heapreplace()
+    # time complexity: O(log(n)), improving the performance
+    dummy_nums = min_heap.copy()  # copy all elements to another list
+    data = -1
+    popped_value = heapq.heappushpop(min_heap, data)  # 1st push then pop
+    print(f"popped value: {popped_value}")
+
+    popped_value = heapq.heapreplace(dummy_nums, data)  # 1st pop from existing min then push
+    print(f"popped value: {popped_value}")
+
+    print(f"========================================")
+    print(f"demo nlargest / smallest element or element ")
+    print(f"========================================")
+
+    # k largest / smallest elements
+    # best for smaller values of k
+    min_heap.append(100)
+    min_heap.append(200)
+    min_heap.append(50)
+    print(f"nums = {min_heap}")
+
+    large_items = heapq.nlargest(3, min_heap)
+    small_items = heapq.nsmallest(3, min_heap)
+    print(f"3 largest values: {large_items}")
+    print(f"3 smallest values: {small_items}")
+    # when k==1, it is more efficient to use the built-in min() and max() functions.
+
+    # for larger k values it is more efficient to use the sorted() function.
+
+    # kth largest element
+    k = 3
+    kth_large = heapq.nlargest(k, min_heap)[-1]
+    print(f"{k}th/rd/nd largest value: {kth_large}")  # last element of the kth_large list
+
+    # demo max heap
+    demo_max_heap()
+
+    # demo satellite data in the max heap
+    demo_max_satellite_heap()
+
+
+if __name__ == '__main__':
+    main()

core_concepts/demo_modules/queue/demo_queue.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+
+# author: greyshell
+# description: how to use queue ADT
+
+from collections import deque as queue
+
+
+def main():
+    q = queue()
+    # enque: adding items at rear
+    q.append(9)
+    q.append(5)
+    q.append(3)
+    q.append(1)
+
+    # display the queue elements
+    print(f"display the queue elements: {list(q)}")
+
+    # dequeue: deleting items from front
+    data = q.popleft()
+    print(f"item deleted from font: {data}")
+    print(f"display the queue elements: {list(q)}")
+
+    # peek
+    print(f"peek the front: {q[0]}")
+    print(f"peek the rare: {q[-1]}")
+
+    # dequeue at rear
+    data = q.pop()
+    print(f"item deleted from rare: {data}")
+
+
+if __name__ == '__main__':
+    main()

core_concepts/demo_modules/stack/demo_stack.py

@@ -0,0 +1,46 @@
+# !/usr/bin/env python3
+
+# author: greyshell
+# description: stack using list
+
+
+def main():
+    """
+    - python list is backed by dynamic array, so occasionally it needs to be resized when item
+    is added / removed
+    - it does not guarantee the stable O(1) push and pop
+    - however, it provides the amortize time complexity is O(1) when the item is added / remove at
+    the end of list
+    - adding / removing from front / middle is much slower and it takes O(n) time as shifting of
+    existing elements
+    are required
+    - no parallel processing support / it handles locking and unlocking
+    :return:
+    """
+    s = list()
+    # push: O(1), stack grows from left to right
+    s.append(9)
+    s.append(5)
+    s.append(3)
+    s.append(2)
+
+    # display the stack elements
+    print(f"display the stack elements: {s}")
+
+    # peek, O(1)
+    data = s[-1]
+    print(f"peek the stack top: {data}")
+
+    # pop: O(1), stack shrinks from right to left
+    # raise IndexError => pop from an empty list
+    try:
+        data = s.pop()
+        print(f"popped: {data}")
+    except IndexError as e:
+        print(f"{e}")
+
+    print(f"display the stack elements: {list(s)}")
+
+
+if __name__ == '__main__':
+    main()

core_concepts/demo_modules/stack/demo_stack02.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+
+# author: greyshell
+# description: stack using deque
+
+from collections import deque
+
+
+def main():
+    """
+    - deque is backed by doubly linked list
+    - it that guarantees the stable O(1) push and pop
+    - no parallel processing support / it handles locking and unlocking
+    :return:
+    """
+    s = deque()
+    # push: O(1), stack grows from left to right
+    s.append(9)
+    s.append(5)
+    s.append(3)
+    s.append(1)
+
+    # display the stack elements: convert the deque into list
+    print(f"display the stack elements: {s}")
+    print(f"display the stack elements: {list(s)}")
+
+    # peek, O(1)
+    data = s[-1]
+    print(f"peek the stack top: {data}")
+
+    # pop: O(1), stack shrinks from right to left
+    # raise IndexError => pop from an empty list
+    try:
+        data = s.pop()
+        print(f"popped: {data}")
+    except IndexError as e:
+        print(f"{e}")
+
+    print(f"display the stack elements: {list(s)}")
+
+
+if __name__ == '__main__':
+    main()

core_concepts/demo_modules/stack/demo_stack03.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+
+# author: greyshell
+# description: stack using queue.LifoQueue
+
+from queue import LifoQueue
+
+
+def main():
+    """
+    - used for parallel computing / multi producer and consumer scenarios
+    - locking and un-locking needs to be implemented manually
+    :return:
+    """
+    s = LifoQueue()
+    # push: O(1)
+    s.put(9)
+    s.put(2)
+
+    # check if the stack is empty
+    print(f"{s.empty()}")
+
+    # not found any method for peek and display stack elements
+
+    # pop: O(1)
+    data = s.get_nowait()
+    data = s.get_nowait()
+
+    try:
+        data = s.get_nowait()  # not wait for producer to add the element if the stack is empty
+        print(f"popped: {data}")
+    except Exception as e:
+        print(f"{e}")
+
+    exit(0)
+
+    data = s.get()  # popped out the last stack element
+    data = s.get()  # waits for ever as the stack is empty, producer needs to add an element
+    print(f"popped: {data}")
+
+
+if __name__ == '__main__':
+    main()