User-defined Data structures in Python

User-defined data structures are not inbuilt in Python, but we can still implement them. We can use the existing functional options in Python to create new data structures. For example, when we say a list = [], Python recognizes it as a list and calls everything related to a list. But when we say a linked list or a queue, Python won't know what these are. In this article, we will discuss some user-defined data structures in Python:

1. Linked Lists

A linked list, like its name suggests, is linked. Every node in the linked list consists of two segments- the data field with the data/ value and the next field holding the reference to the next node, thus linking together. It is a linear data structure, but the elements are not stored in contiguous memory locations.

Important points about Linked lists:

A linked list is an ordered collection of elements.
A linked list is also used to implement other user-defined data structures like stack and queue.
Using the collections module in Python, we can use the deque object to implement operations like insert and delete on linked lists.
The first node in a linked list is the head, and we must start all the operations on the linked list from it.
The last node of the linked list refers to None showing that the linked list is complete.

Further, linked lists are of three types:

Simple linked list
Double linked list
Circular linked list

A simple linked list looks like this:

As shown in the above figure, the head is the first node, and the next (reference) part of the last node holds None.

A double-linked list looks like this:

In a double-linked list, every node will have three sections. Head holds the reference of the first node, the "previous" section of the first node holds None, and the next field of the last node refers to None. Each node will hold two references along with the data, one to its previous node and the next to the succeeding node.

Circular linked list:

A circular linked list can be single or double:

Circular single linked list:

It is a single linked list, but the last node in the list holds the reference of the first node like a circle.

Circular double-linked list:

It is a double-linked list, but the last node in the list holds the reference of the first node, and the 'previous' section of the first node holds the reference of the last node like a circle.

Example Program:

#Creating and displaying a linked list
class node:
    def __init__(self, data):
        self.data = data
        self.next = None
class LL:
    def __init__(self):
        self.head = None
    #Displaying
    def __repr__(self):
        node = self.head
        nodes = []
        while node is not None:
            nodes.append(node.data)
            node = node.next
        nodes.append("None")
        return " -> ".join(map(str, nodes))
    #insert a node at the beginning
    def insertatbeg(self, newdata):
       newnode = node(newdata)
       newnode.next = self.head
       self.head = newnode
     #insert a node at the ending
    def insertatend(self, newdata):
        newnode = node(newdata)
        if(self.head is None):
            self.head = newnode
            return
        i = self.head
        while(i.next != None):
            i = i.next
        i.next = newnode
    #insert a node after the specified node
    def insertafteranode(self, givennodedata, newdata):
        i = self.head
        newnode = node(newdata)
        while(i.data != givennodedata):
            givennode = i.next
            i = i.next
        newnode.next = givennode.next
        givennode.next = newnode
    #insert a node before the specified node
    def insertbeforeanode(self, givennodedata, newdata):
        i = self.head
        newnode = node(newdata)
        while(i.next.data != givennodedata):
            givennode = i.next.next
            i = i.next
        i.next = newnode
        newnode.next = givennode
    #traversing the LinkedList
    def traversal(self):
        temp = self.head
        while(temp != None):
            print(temp.data)
            temp = temp.next
Llist = LL()
Llist.head = node(10)
node2 = node(20)
node3 = node(30)
Llist. head.next = node2
node2.next = node3
print("Displaying the linked list: ", Llist)
#Traversing call
print("Traversing from node to node:")
Llist.traversal()
#Insertion call
Llist.insertatbeg(5)
print("After inserting 5 at the beginning:", Llist)
Llist.insertatend(40)
print("After inserting 40 at the end:", Llist)
Llist.insertafteranode(10, 15)
print("After inserting a node after 15:", Llist)
Llist.insertbeforeanode(30, 25)
print("After inserting a node before 30:", Llist)

Output:

Displaying the linked list:  10 -> 20 -> 30 -> None
Traversing from node to node:
10
20
30
After inserting 5 at the beginning: 5 -> 10 -> 20 -> 30 -> None
After inserting 40 at the end: 5 -> 10 -> 20 -> 30 -> 40 -> None
After inserting a node after 15: 5 -> 10 -> 15 -> 20 -> 30 -> 40 -> None
After inserting a node before 30: 5 -> 10 -> 15 -> 20 -> 25 -> 30 -> 40 -> None

2. Stack

Stack is a linear data structure. It is implemented on the principle "LIFO" abbreviation: Last in, first out. It means that the element that is last inserted into a stack will be the first one that gets deleted. A stack only has one opening, which means to insert or delete elements; we need to use the same end. When we insert elements into a stack, we insert elements on top of each other-new elements on the existing element. After inserting all the elements, if we want to delete elements from the stack, the last element inserted will be the first to come out.

Terminologies:

Inserting an element into the stack: push
Deleting an element from the stack: pop
The end/ opening of the stack: top of the stack

Functions in Python for stacks:

Implementation of a stack:

We can implement a stack:

Using lists
Using linked lists
Using deque
Using queues

#Implementation of stacks using lists
stack = []
#pushing elements
stack.append(1)
stack.append(2)
stack.append(3)
#Printing the stack
print("The elements of the stack")
for i in stack:
    print(i)
#popping elements
print("The first element to come out:", stack.pop())
print("The second element to come out:", stack.pop())
print("Final stack:", stack)

Output:

The elements of the stack
1
2
3
The first element to come out: 3
The second element to come out: 2
Final stack: [1]

Implementation by lists is the simplest implementation of all. To push elements into the stack, we use the list's append() method, and to pop the elements, we use the stack's pop()

#Stack implementation using a Linked list
class node:
    def __init__(self, data):
        self.data = data
        self.next = None
class Stack:
    def __init__(self):
        self.head = node("head")
        self.size = 0
    def size(self):
        #size of the stack
        return self.size
    def top(self):
        #Top of the stack
        if(self.size==0):
            raise Exception("Empty stack")
        return self.head.next.data
    def push(self, data):
        Node = node(data)
        Node.next = self.head.next
        self. head.next = Node
        self.size += 1
    def pop(self):
        if(self.size==True):
            raise Exception("Empty stack")
        temp = self.head.next
        self. head.next = self.head.next.next
        self.size -= 1
        return temp.data
    def __repr__(self):
        #Representation
        Node = self.head
        nodes = []
        while node is not None:
            nodes.append(Node.data)
            Node = Node.next
        nodes.append("None")
        return " ".join(map(str, nodes))
mystack = Stack()
print("Stack without pushing any elements:", mystack)
for i in range(10, 15):
    mystack.push(i)
print("Stack after pushing elements:\n", mystack)
print("After pop 3 times:")
for i in range(0, 3):
    print(mystack.pop())
print("Stack:\n", mystack)
print("Element at the top of the stack:")
print(mystack.top())
print("Pop till stack becomes empty:")
for i in range(0, 3):
    print(mystack.pop())

Output:

Stack without pushing any elements: head None
Stack after pushing elements:
 head 14 13 12 11 10 None
After pop 3 times:
14
13
12
Stack:
 head 11 10 None
Element at the top of the stack:
11
Pop till stack becomes empty:
11
10
Traceback (most recent call last):
  File "D:\Programs\DSA \Language\Python data structures programs\stacks.py", line 59, in 
    print(mystack.pop())
  File "D:\Programs\DSA\Language\Python data structures programs\stacks.py", line 34, in pop
    raise Exception("Empty stack")
Exception: Empty stack

We wrote two methods push and pop, to implement a stack. We need to make sure of two points:

When push is performed, we should always add the elements at the beginning of the linked list.
When pop is performed, the element from the beginning has to be deleted.
We created size() and isEmpty(), and top() to check if the stack is empty because if a stack is empty, we can't perform pop.

3. Queues

A queue is a linear data structure like a stack, but the principle of queue implementation is FIFO-First in, first out. It means that the first element inserted into the queue will be the first element to come out of the queue.

Important points about a queue:

There will be two ends to a queue-front and rear ends.
The elements are inserted from the front end and deleted from the rear end.

Terminology:

Inserting an element into a queue: enqueue
Deleting an element from the queue: dequeue
Element at the beginning: front
Element at the end: rear

We can implement a queue in Python:

Using lists
Using collections module
Using queue.Queue

#Implementation of queue using lists
print("Using lists:")
Queue1 = []
print("Queue: ", Queue1)
print("Inserting elements:")
for i in range(1, 6):
    Queue1.append(i)
print("Queue:", Queue1)
print("Deleting two elements:")
for i in range(0, 2):
    Queue1.pop(0)
print("Final queue:", Queue1)

#Implementation using collection module
print("\nUsing the deque class in collection module")
from collections import deque
Queue2 = deque()
print("Inserting elements:")
for i in range(6, 11):
    Queue2.append(i)
print("Queue:", Queue2)
print("Deleting elements:")
for i in range(0, 2):
    Queue2.popleft()
print("Final queue:", Queue2)

#Implementation using queue module
print("\nUsing the Queue class in queue module")
import queue
Queue3 = queue.Queue(maxsize = 6)
print("Inserting elements:")
for i in range(6):
    Queue3.put(i)
print("Queue:")
for i in list(Queue3.queue):
    print(i, end = " ")
print("\nIs the queue full?", Queue3.full())
print("Deleting elements:")
for i in range(0, 2):
    Queue3.get()
print("Final queue:", list(Queue3.queue))
print("size of the queue:", Queue3.qsize())

Output:

Using lists:
Queue:  []
Inserting elements:
Queue: [1, 2, 3, 4, 5]
Deleting two elements:
Final queue: [3, 4, 5]

Using the deque class in the collection module
Inserting elements:
Queue: deque([6, 7, 8, 9, 10])
Deleting elements:
Final queue: deque([8, 9, 10])

Using the Queue class in the queue module
Inserting elements:
Queue:
0 1 2 3 4 5 
Is the queue full? True
Deleting elements:
Final queue: [2, 3, 4, 5]
size of the queue: 4

All the inbuilt python methods used in different modules are shown above:
A queue can be related to queues in real life. The person who starts the queue gets the ticket to the movie first.

There can be a scenario of high-priority situations where irrespective of the order, we must take care of some aspects first. For such situations, there is a type of queue: Priority Queue.

Difference between Queue and Priority Queue

push(element)	Inserts the specified element into the stack
pop()	Deletes and returns the element at the top of the stack
top()	Returns the element at the top of the stack
peek()	Same as the top()
size()	Returns the size of the specified stack
empty()	Checks if the given stack is empty

Regular Queue	Priority Queue
The element at the rear end is deleted when the deque operation is performed.	When the deque operation is performed, the element with the highest priority is deleted. If two elements have the same priority, the first inserted element is deleted.
After the deque operation, the elements remain in FIFO order.	After the deque operation, the elements will either be in increasing or decreasing order.

Implementation:

class PriorityQ:
    def __init__(self):
        self.PQ = []
    def enqueue(self, data):
        self.PQ.append(data)
    def __str__(self):
        return ' '.join([str(i) for i in self.PQ])
    def dequeue(self):
        max = 0
        for i in range(len(self.PQ)):
            if(self.PQ[i] > self.PQ[max]):
                max = i
        temp = self.PQ[max]
        del self.PQ[max]
        self.PQ.sort()
        return temp
Q = PriorityQ()
Q.enqueue(3)
Q.enqueue(2)
Q.enqueue(19)
Q.enqueue(90)
Q.enqueue(11)
print("Created Q:", Q)
print("Dequeue operation:")
print("The element to be deleted:", Q.dequeue())
print("Final PQ:", Q)

Output:

Created Q: 3 2 19 90 11
Dequeue operation:
The element to be deleted: 90
Final Queue: 2 3 11 19

4. Binary Tree

A tree is a hierarchical representation of nodes. Family trees are real-time examples of a tree. Every node is allowed to have only two children. The node at the highest hierarchy or the top-most node is called the "Root node".

Important points about Binary tree:

Every node can have a left sub-tree and a right sub-tree.
Hence, a node in a binary tree has 3 segments: data, a reference to the left child, and a reference to the right child.
The nodes with the lowest hierarchy without any children are called leaf nodes.
A tree can be traversed using 2 methods:
1. DFS: By depth
2. BFS: By breadth (or) level
DFS traversal further has three types of traversals:
1. Pre-order Traversal: The root is first visited, then the left sub-tree, followed by the right sub-tree.
2. Post-order Traversal: The left sub-tree is visited first, then the right sub-tree, followed by the root node.
3. In-order traversal: The left sub-tree is visited first, then the root node, followed by the right sub-tree.
BFS traversal is when we visit the tree level-wise.

class TreeNode:
    def __init__(self, value):
        self.left = None
        self.right = None
        self.value = value
def Inorder(root):
      if(root):
          Inorder(root.left)
          print(root.value, end = " ")
          Inorder(root.right)
def Preorder(root):
    if(root):
        print(root.value, end = " ")
        Preorder(root.left)
        Preorder(root.right)
def Postorder(root):
    if(root):
        Postorder(root.left)
        Postorder(root.right)
        print(root.value, end = " ")
def BFS(root):
    if root is not None:
        Q = []
        Q.append(root)
        while(len(Q) > 0):
            print(Q[0].value, end = " ")
            temp = Q.pop(0)
            if temp.left is not None:
                Q.append(temp.left)
            if temp.right is not None:
                Q.append(temp.right)
root = TreeNode(4)
root.left = TreeNode(3)
root.right = TreeNode(5)
root.left.left = TreeNode(2)
root.left.right = TreeNode(3)
print("Preorder traversal:")
Preorder(root)
print("\nPostorder traversal:")
Postorder(root)
print("\nInorder traversal:")
Inorder(root)
print("\nBFS traversal:?)
BFS(root)

Output:

Preorder traversal:
4 3 2 3 5 
Postorder traversal:
2 3 3 5 4 
Inorder traversal:
2 3 3 4 5
BFS traversal:
4 3 5 2 3

There is a type of Binary Tree called the BST or Binary Search Tree. There are three qualifications a binary tree must pass to become a BST:

The values of the nodes in the left sub-tree must be less than the value of the root node.
The values of the nodes in the right sub-tree must be greater than the value of the root node.
Every sub-tree in the tree must also follow the BST property.

Here is an example BST:

5. Graphs

In short form, G = (V, E). Here V represents vertices, and E represents edges. A graph is a non-linear Data structure. It consists of nodes/ vertices joined/ connected by edges. Both vertices and edges have to be a finite set. An edge can be represented as (u, v) given u and v are the two vertices the edge connects.

A graph can be directed or undirected. In an undirected graph, E = (u, v) and E = (v, u) are the same, while in a directed graph, they are not the same as the directed matters. Hence, edges are represented as ordered pairs of vertices the edge joins.

Important points about graphs:

The edges of a graph can have costs or weights.
Networks in real-time are represented using Graphs.
A graph can be implemented using:
1. Incidence matrix
2. Incidence List
3. Adjacency Matrix
4. Adjacency List
It is the programmer's choice of how to implement the graph based on the need in the scenario.
A graph can consist of cycles.
For graph traversal, BFS and DFS techniques are used like in trees, but to avoid visiting the same vertex again and again in the case of cycles, we need to maintain an array of visited vertices not to visit them again.

Adjacency matrix: An adjacency matrix is a (V X V) 2D array where V represents the vertices in the graph. In the matrix, adj[u][v], if in the graph, there exists an edge between u and v, adj[u][v] = 1, else 0 is assigned.

In an undirected graph, if there exists an edge from u to v, adj[u][v] = 1 and adj[v][u] = 1 as there are no directions. Hence, the adjacency matrix of an undirected graph is always symmetrical.
In a directed graph, adj[u][v] is not equivalent to adj[v][u].
If the edges have weights are costs given, in the place of 1, we give the assigned weight/ cost in the matrix.
The disadvantage of this representation is that it takes more space-O(V²)

Here is the representation:

Here is a very simple code of adjacency matrix implementation for the graph:

class matrix:
    def __init__(self, no_of_V):
        self.no_of_V = no_of_V
        self.mat = [[0]*no_of_V for i in range(0, no_of_V)]
        self.vertices = {}
    def set_v(self, no, name):
        self.vertices[name] = no
    def set_edge(self, to, by, cost):
        to = self.vertices[to]
        by = self.vertices[by]
        self.mat[to][by] = cost
        self.mat[by][to] = cost # Avoid the line if the graph is directed
    def get_mat(self):
        return self.mat
graph = matrix(5)
graph.set_v(0, 'A')
graph.set_v(1, 'B')
graph.set_v(2, 'C')
graph.set_v(3, 'D')
graph.set_v(4, 'E')
graph.set_edge('A', 'B', 3)
graph.set_edge('B', 'C', 5)
graph.set_edge('C', 'E', 2)
graph.set_edge('E', 'D', 7) 
graph.set_edge('A', 'D', 12) 
graph.set_edge('A', 'E', 4)
adj_mat = graph.get_mat()
for i in range(5):
    for j in range(5):
        print(adj_mat[i][j], end = " ")
    print()

Output:

Adjacency list:

To implement an adjacency list, we use an array/ list of linked lists to represent the vertices and edges in the graph. The number of linked lists used in the representation equals the number of vertices in the graph.

An array with length = no-of vertices is created, and for every vertex, we will create a linked list with all the adjacent vertices, and these linked lists will be arranged in the array.
In the case of a directed graph, all the nodes/ vertices we can travel to from the node in the array are linked in the linked list.
Simple, an adjacency list is an array of linked lists with adjacent nodes of the first node.

Here is the representation:

In the above adjacency list representation, the graph is undirected. Hence, each node's neighboring nodes in the graph are linked as separate linked lists.

This is a directed graph. Hence, for each node in the graph, adjacent/ neighboring nodes that we can direct from the node are linked.
Also, costs are given to every edge in the graph. Hence, the costs are also represented in the linked lists.

Here is a simple code with an adjacency list representation of a graph:

class node:
    def __init__(self, vertex):
        self.vertex = vertex
        self.next = None
class adjlist:
    def __init__(self, no_of_V):
        self.no_of_V = no_of_V
        self.graph = [None]*self.no_of_V

    def edge(self, by, to):
        vertex = node(to)
        vertex.next = self.graph[by]
        self.graph[by] = vertex
        
        #Include the next three lines only if the graph is undirected
        vertex = node(by)
        vertex.next = self.graph[to]
        self.graph[to] = vertex
        
    def display(self):
        for i in range(self.no_of_V):
            print(str(i) + ":", end = "")
            temp = self.graph[i]
            while temp:
                print(" -> {}".format(temp.vertex), end= "")
                temp = temp.next
            print("\n")

graph = adjlist(5)
graph.edge(0, 1)
graph.edge(0, 2)
graph.edge(1, 3)
graph.edge(1, 2)
graph.edge(1, 4)
graph.edge(3, 4)
graph.edge(2, 4)
graph.display()

Output:

0: -> 2 -> 1

1: -> 4 -> 2 -> 3 -> 0

2: -> 4 -> 1 -> 0

3: -> 4 -> 1

4: -> 2 -> 3 -> 1

Understanding:

A list of the size number of vertices in the graph is created with all None values:

[None, None, None, None, None]

Now, when an edge(source, destination) call is made:

Using the class node, a destination node is created, and its next is pointed to the source in the array, and then the linked list is assigned to the source position in the array.

When edge(0, 1) is called:

[1 -> None, 0 -> None, None, None, None]

edge(0, 2):

[2 -> 1 -> None, 0 -> None, 0 -> None, None, None]

edge(1, 3):

[2 -> 1 -> None, 3 -> 0 -> None, 0 -> None, 1 -> None, None]

This way, all the adjacent nodes are attached to the linked lists in the array.

Next TopicFind the Number that Appears Once

← prev next →