Data Structures: from lists to maps

Author: Flor Silvestre

.gitignore

@@ -2,6 +2,7 @@
 __pycache__/
 *.py[cod]
 *$py.class
+.vscode
 
 # C extensions
 *.so

data-structures/data-structures.md

@@ -21,7 +21,7 @@ The data in the data structures are processed by certain operations. The particu
 * Sorting
 * Merging
 
-## Array Data Structure
+## [Array](arrays.py)
 
 ![Array](assets/array-2.png)
 
@@ -59,22 +59,6 @@ deletion: O(n)
 
 *Python has a set of built-in methods that you can use on lists/arrays.*
 
-Create:
-```
-cars = ["Ford", "Volvo", "BMW"]
-```
-
-Access element:
-```
-x = cars[0]
-```
-
-Loop:
-```
-for x in cars:
-  print(x)
-```
-
 | Method    | Description  |
 |:-:        |  ---         |
 | append()  | Adds an element at the end of the list  |
@@ -87,29 +71,87 @@ for x in cars:
 | pop()	    | Removes the element at the specified position |
 | remove()	| Removes the first item with the specified value |
 | reverse()	| Reverses the order of the list | 
-| sort()	| Sorts the list |
+| sort()	  | Sorts the list |
+
+## [Matrix](matrix.py)
+
+![Matrix](assets/matrix-9.png)
+
+A matrix represents a collection of numbers arranged in an order of rows and columns. It is necessary to enclose the elements of a matrix in parentheses or brackets.
+
+Matrix is a special case of two dimensional array where each data element is of strictly same size. So every matrix is also a two dimensional array but not vice versa. Matrices are very important data structures for many mathematical and scientific calculations. As we have already discussed two dimnsional array data structure in the previous chapter we will be focusing on data structure operations specific to matrices in this chapter.
+
+We also be using the numpy package for matrix data manipulation.
+
+## [List](lists.py)
+
+It is similar to array with the exception that the data elements can be of different data types. You can have both numeric and string data in a python list.
+
+## [Tuple](tuples.py)
+
+Tuples are similar to lists but they are immutable which means the values in a tuple cannot be modified they can only be read.
+
+A tuple is a sequence of immutable Python objects. Tuples are sequences, just like lists. The differences between tuples and lists are, the tuples cannot be changed unlike lists and tuples use parentheses, whereas lists use square brackets.
+
+## [Dictionary](dictionary.py)
+
+The dictionary contains Key-value pairs as its data elements.
+
+In Dictionary each key is separated from its value by a colon (:), the items are separated by commas, and the whole thing is enclosed in curly braces. An empty dictionary without any items is written with just two curly braces, like this: {}.
+
+Keys are unique within a dictionary while values may not be. The values of a dictionary can be of any type, but the keys must be of an immutable data type such as strings, numbers, or tuples.
+
+- More than one entry per key not allowed. Which means no duplicate key is allowed. When duplicate keys encountered during assignment, the last assignment wins.
+
+- Keys must be immutable. Which means you can use strings, numbers or tuples as dictionary keys but something like ['key'] is not allowed.
+
+## [Sets](sets.py)
+
+Mathematically a set is a collection of items not in any particular order. A Python set is similar to this mathematical definition with below additional conditions.
+
+* The elements in the set cannot be duplicates.
+* The elements in the set are immutable(cannot be modified) but the set as a whole is mutable.
+* There is no index attached to any element in a python set. So they do not support any indexing or slicing operation.
 
-## Linked list
+#### Set Operations
+
+The sets in python are typically used for mathematical operations like union, intersection, difference and complement etc. 
+
+We can create a set, access it’s elements and carry out these mathematical operations.
+
+## [Maps](maps.py)
+
+Python Maps also called ChainMap is a type of data structure to manage multiple dictionaries together as one unit. The combined dictionary contains the key and value pairs in a specific sequence eliminating any duplicate keys. The best use of ChainMap is to search through multiple dictionaries at a time and get the proper key-value pair mapping. We also see that these ChainMaps behave as stack data structure.
+
+## [Linked list](linked_lists.py)
 
 ![Linked list](assets/Linkedlist.png)
 
-- A **linked list** (also just called *list*) is a linear collection of data elements of any type, called nodes, where each node has itself a value, and points to the next node in the linked list. The principal advantage of a linked list over an array, is that values can always be efficiently inserted and removed without relocating the rest of the list. Certain other operations, such as random access to a certain element, are however slower on lists than on arrays.
+- A **linked list** is a linear collection of data elements of any type, called nodes, where each node has itself a value, and points to the next node in the linked list. The principal advantage of a linked list over an array, is that values can always be efficiently inserted and removed without relocating the rest of the list. Certain other operations, such as random access to a certain element, are however slower on lists than on arrays.
+
+Python does not have linked lists in its standard library. We implement the concept of linked lists using the concept of nodes as discussed in the previous chapter. We have already seen how we create a node class and how to traverse the elements of a node.
 
-**Types of Linked List:**
+### Types of Linked List:
 
 **Singly Linked List**: In this type of linked list, every node stores address or reference of next node in list and the last node has next address or reference as NULL. 
 
 For example 1->2->3->4->NULL
 
-**Doubly Linked List**: Here, here are two references associated with each node, One of the reference points to the next node and one to the previous node. 
+[**Doubly Linked List**](doubly_linked_list.py): Here, here are two references associated with each node, One of the reference points to the next node and one to the previous node. 
+* Doubly Linked List contains a link element called first and last.
+* Each link carries a data field(s) and two link fields called next and prev.
+* Each link is linked with its next link using its next link.
+* Each link is linked with its previous link using its previous link.
+* The last link carries a link as null to mark the end of the list.
+
 Eg. NULL<-1<->2<->3->NULL
 
 **Circular Linked List**: Circular linked list is a linked list where all nodes are connected to form a circle. There is no NULL at the end. A circular linked list can be a singly circular linked list or doubly circular linked list. 
 
 Eg. 1->2->3->1 [The next pointer of last node is pointing to the first]
 
 
-**How is an Array different from Linked List?**
+### **How is an Array different from Linked List?**
 
 - The size of the arrays is fixed, Linked Lists are Dynamic in size.
 - Inserting and deleting a new element in an array of elements is expensive, Whereas both insertion and deletion can easily be done in Linked Lists.
@@ -134,7 +176,7 @@ searching: O(n)
 insertion: O(1)
 deletion: O(1)
 
-## Stack
+## [Stack](stacks.py)
 
 ![Stack](assets/stack.png)
 
@@ -164,19 +206,19 @@ Reverse a String using Stack
 Implement two stacks in an array
 Check for balanced parentheses in an expression
 
-## Queue
+## [Queue](queues.py)
 
-![Stack](assets/Queue.png)
+![Queues](assets/Queue.png)
 
 A Queue is a linear structure which follows a particular order in which the operations are performed. The order is First In First Out (FIFO). A good example of a queue is any queue of consumers for a resource where the consumer that came first is served first. The difference between stacks and queues is in removing. In a stack we remove the item the most recently added; in a queue, we remove the item the least recently added.
 
  Mainly the following are basic operations on queue: **Enqueue, Dequeue, Front, Rear**
 
 The difference between stacks and queues is in removing. In a stack we remove the item the most recently added; in a queue, we remove the item the least recently added. Both Queues and Stacks can be implemented using Arrays and Linked Lists.
 
-## Binary Tree
+## [Binary Tree](binary_tree.py)
 
-![Stack](assets/binary-tree-to-DLL.png)
+![Binary tree](assets/binary-tree-to-DLL.png)
 
 A tree whose elements have at most 2 children is called a binary tree. Since each element in a binary tree can have only 2 children, we typically name them the left and right child.
 
@@ -186,9 +228,9 @@ A Binary Tree node contains following parts.
 - Pointer to left child
 - Pointer to right child
 
-### Binary search tree (BST)
+### [Binary search tree (BST)](binary_search_tree.py)
 
-![Stack](assets/BSTSearch.png)
+![Binary search tree](assets/BSTSearch.png)
 
 Binary Search Tree is a node-based binary tree data structure which has the following properties:
 
@@ -200,9 +242,9 @@ searching: O(log n)
 insertion: O(log n)
 deletion: O(log n)
 
-### Heap
+### [Heap](heap.py)
 
-![Stack](assets/MinHeapAndMaxHeap.png)
+![Heap](assets/MinHeapAndMaxHeap.png)
 
 A Heap is a special Tree-based data structure in which the tree is a complete binary tree. Generally, Heaps can be of two types:
 
@@ -213,9 +255,18 @@ min/max: O(1)
 insertion: O(log n)
 deletion: O(log n)
 
-## Hash Tables
+## [Hash Tables](hash_tables.py)
 
-![Stack](assets/HashingDataStructure-min-768x384.png)
+![Hash Tables](assets/HashingDataStructure-min-768x384.png)
+
+Hash tables are a type of data structure in which the address or the index value of the data element is generated from a hash function. That makes accessing the data faster as the index value behaves as a key for the data value. In other words Hash table stores key-value pairs but the key is generated through a hashing function.
+
+So the search and insertion function of a data element becomes much faster as the key values themselves become the index of the array which stores the data.
+
+In Python, the Dictionary data types represent the implementation of hash tables. The Keys in the dictionary satisfy the following requirements.
+
+* The keys of the dictionary are hashable i.e. the are generated by hashing function which generates unique result for each unique value supplied to the hash function.
+* The order of data elements in a dictionary is not fixed.
 
 Hashing is an important Data Structure which is designed to use a special function called the Hash function which is used to map a given value with a particular key for faster access of elements. The efficiency of mapping depends of the efficiency of the hash function used.
 
@@ -225,34 +276,10 @@ value lookup: O(1)
 insertion: O(1)
 deletion: O(1)
 
-## Graphs
+## [Graphs](graphs.py)
 
-![Stack](assets/undirectedgraph.png)
+![Graph](assets/undirectedgraph.png)
 
 A Graph is a non-linear data structure consisting of nodes and edges. The nodes are sometimes also referred to as vertices and the edges are lines or arcs that connect any two nodes in the graph. More formally a Graph can be defined as,
 
 A Graph consists of a finite set of vertices(or nodes) and set of Edges which connect a pair of nodes.
-
-## Matrix
-
-![Stack](assets/matrix-9.png)
-
-A matrix represents a collection of numbers arranged in an order of rows and columns. It is necessary to enclose the elements of a matrix in parentheses or brackets.
-
-## PYTHON SPECIFIC DATA STRUCTURES
-
-These data structures are specific to python language and they give greater flexibility in storing different types of data and faster processing in python environment.
-
-**List**: It is similar to array with the exception that the data elements can be of different data types. You can have both numeric and string data in a python list.
-
-**Tuple**: Tuples are similar to lists but they are immutable which means the values in a tuple cannot be modified they can only be read.
-A tuple is a sequence of immutable Python objects. Tuples are sequences, just like lists. The differences between tuples and lists are, the tuples cannot be changed unlike lists and tuples use parentheses, whereas lists use square brackets.
-
-**Dictionary**: The dictionary contains Key-value pairs as its data elements.
-In Dictionary each key is separated from its value by a colon (:), the items are separated by commas, and the whole thing is enclosed in curly braces. An empty dictionary without any items is written with just two curly braces, like this: {}.
-
-Keys are unique within a dictionary while values may not be. The values of a dictionary can be of any type, but the keys must be of an immutable data type such as strings, numbers, or tuples.
-
-- More than one entry per key not allowed. Which means no duplicate key is allowed. When duplicate keys encountered during assignment, the last assignment wins.
-
-- Keys must be immutable. Which means you can use strings, numbers or tuples as dictionary keys but something like ['key'] is not allowed.

data-structures/doubly_linked_list.py

@@ -0,0 +1,57 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+        self.prev = None
+
+
+class doubly_linked_list:
+    def __init__(self):
+        self.head = None
+    
+    # Adding data elements
+    def push(self, NewVal):
+        NewNode = Node(NewVal)
+        NewNode.next = self.head
+        if self.head is not None:
+            self.head.prev = NewNode
+        self.head = NewNode
+
+    # Print the Doubly Linked list
+    def listprint(self, node):
+        while (node is not None):
+            print(node.data)
+        last = node
+        node = node.next
+        
+    def insert(self, prev_node, NewVal):
+        if prev_node is None:
+            return
+        NewNode = Node(NewVal)
+        NewNode.next = prev_node.next
+        prev_node.next = NewNode
+        NewNode.prev = prev_node
+        if NewNode.next is not None:
+            NewNode.next.prev = NewNode
+    
+    def append(self, NewVal):
+        # Adds the element at the last
+        NewNode = Node(NewVal)
+        NewNode.next = None
+        if self.head is None:
+            NewNode.prev = None
+            self.head = NewNode
+            return
+        last = self.head
+        while (last.next is not None):
+            last = last.next
+        last.next = NewNode
+        NewNode.prev = last
+        return
+
+dllist = doubly_linked_list()
+dllist.push(12)
+dllist.push(8)
+dllist.push(62)
+dllist.insert(dllist.head.next, 13)
+dllist.listprint(dllist.head)

data-structures/linked_lists.py

@@ -0,0 +1,87 @@
+"""
+    Linked list implementation
+"""
+class Node:
+    def __init__(self, dataval=None):
+        self.dataval=dataval
+        self.nextval=None
+
+class SLinkedList:
+    def __init__(self):
+        self.headval=None
+    
+    def listprint(self):
+        """
+            Print the linked list
+        """
+        printval = self.headval
+        while printval is not None:
+            print (printval.dataval)
+            printval = printval.nextval
+
+    def insertAtBegining(self, value):
+        """
+            Insert a new value at the begining of the list
+        """
+        new_node = Node(value)
+        new_node.nextval = self.headval
+        self.headval = new_node
+    
+    def insertAtEnd(self, value):
+        """
+            Insert a new value at the end of the list
+        """
+        new_node = Node(value)
+        if self.headval is None:
+            self.headval = new_node
+            return
+        last_node = self.headval
+
+        while(last_node.nextval):
+            last_node = last_node.nextval
+        
+        last_node.nextval = new_node
+    
+    def insertBetween(self, middle_node, value):
+        new_node = Node(value)
+        new_node.nextval = middle_node
+        middle_node.nextval = new_node
+
+    def removeNode(self, key):
+        head = self.headval
+
+        if (head is not None):
+            if (head.data == key):
+                self.headval = head.next
+                head = None
+                return
+
+        while (head is not None):
+            if head.data == key:
+                break
+            prev = head
+            head = head.next
+
+        if (head == None):
+            return
+
+        prev.next = head.next
+
+        head = None
+
+list1 = SLinkedList()
+list.headval = Node("Mon")
+e2 = Node("Tue")
+e3 = Node("Wed")
+
+# Link first Node to second node
+list1.headval.nextval = e2
+
+# Link second Node to third node
+e2.nextval = e3
+
+list1.listprint()
+
+list1.insertAtBegining("Sun")
+
+list1.insertAtEnd("Thu")