From b2a16691059d9b0cff7b544a779299b1722708b1 Mon Sep 17 00:00:00 2001 From: Vinay Date: Sun, 26 May 2024 14:09:10 +0530 Subject: [PATCH] this is commit --- contrib/ds-algorithms/Linked-list.md | 181 +++++++++++++++++++++++++++ contrib/ds-algorithms/index.md | 1 + 2 files changed, 182 insertions(+) diff --git a/contrib/ds-algorithms/Linked-list.md b/contrib/ds-algorithms/Linked-list.md index e69de29..d3d7ec1 100644 --- a/contrib/ds-algorithms/Linked-list.md +++ b/contrib/ds-algorithms/Linked-list.md @@ -0,0 +1,181 @@ +# Linked List Data Structure + +Link list is a linear data Structure which can be defined as collection of objects called nodes that are randomly stored in the memory. +A node contains two types of metadata i.e. data stored at that particular address and the pointer which contains the address of the next node in the memory. +The last node of the list contains pointer to the null. + +## Why use linked list over array? + +From the beginning, we are using array data structure to organize the group of elements that are stored individually in the memory. +However, there are some advantage and disadvantage of array which should be known to decide which data structure will used throughout the program. + +limitations + +1. The size of array must be known in advance before using it in the program. +2. Increasing size of the array is a time taking process. It is almost impossible to expand the size of the array at run time. +3. All the elements in the array need to be contiguously stored in the memory. Inserting any element in the array needs shifting of all its predecessors. + +So we introduce a new data structure to overcome these limitations. + +Linked list is used because, +1. It allocates the memory dynamically. All the nodes of linked list are non-contiguously stored in the memory and linked together with the help of pointers. +2. Sizing is no longer a problem since we do not need to define its size at the time of declaration. List grows as per the program's demand and limited to the available memory space. + +Let's code something + +The smallest Unit: Node + +class Node: + def __init__(self, data): + self.data = data # Assigns the given data to the node + self.next = None # Initialize the next attribute to null + +Now, we will see the types of linked list. + +There are mainly four types of linked list, +1. Singly Link list +2. Doubly link list +3. Circular link list +4. Doubly circular link list + + +## 1. Singly linked list. + +Simply think it is a chain of nodes in which each node remember(contains) the addresses of it next node. + +### Creating a linked list class + +class LinkedList: + def __init__(self): + self.head = None # Initialize head as None + +### Inserting a new node at the beginning of a linked list + + def insertAtBeginning(self, new_data): + new_node = Node(new_data) # Create a new node + new_node.next = self.head # Next for new node becomes the current head + self.head = new_node # Head now points to the new node + +### Inserting a new node at the end of a linked list + + def insertAtEnd(self, new_data): + new_node = Node(new_data) # Create a new node + if self.head is None: + self.head = new_node # If the list is empty, make the new node the head + return + last = self.head + while last.next: # Otherwise, traverse the list to find the last node + last = last.next + last.next = new_node # Make the new node the next node of the last node + +### Inserting a new node at the middle of a linked list + + def insertAtPosition(self, data, position): + new_node = Node(data) + if position <= 0: #check if position is valid or not + print("Position should be greater than 0") + return + if position == 1: + new_node.next = self.head + self.head = new_node + return + current_node = self.head + current_position = 1 + while current_node and current_position < position - 1: #Iterating to behind of the postion. + current_node = current_node.next + current_position += 1 + if not current_node: #Check if Position is out of bound or not + print("Position is out of bounds") + return + new_node.next = current_node.next #connect the intermediate node + current_node.next = new_node + +### Printing the Linked list + + def printList(self): + temp = self.head # Start from the head of the list + while temp: + print(temp.data,end=' ') # Print the data in the current node + temp = temp.next # Move to the next node + print() # Ensures the output is followed by a new line + + +Lets complete the code and create a linked list. + +Connect all the code. + +if __name__ == '__main__': + llist = LinkedList() + + # Insert words at the beginning + llist.insertAtBeginning(4) # <4> + llist.insertAtBeginning(3) # <3> 4 + llist.insertAtBeginning(2) # <2> 3 4 + llist.insertAtBeginning(1) # <1> 2 3 4 + + # Insert a word at the end + llist.insertAtEnd(10) # 1 2 3 4 <10> + llist.insertAtEnd(7) # 1 2 3 4 10 <7> + + #Insert at a random position + llist.insertAtPosition(9,4) ## 1 2 3 <9> 4 10 7 + # Print the list + llist.printList() + + + + output: + 1 2 3 9 4 10 7 + + +### Deleting a node from the beginning of a linked list +check the list is empty otherwise shift the head to next node. + +def deleteFromBeginning(self): + if self.head is None: + return "The list is empty" # If the list is empty, return this string + self.head = self.head.next # Otherwise, remove the head by making the next node the new head + +### Deleting a node from the end of a linked list + +def deleteFromEnd(self): + if self.head is None: + return "The list is empty" + if self.head.next is None: + self.head = None # If there's only one node, remove the head by making it None + return + temp = self.head + while temp.next.next: # Otherwise, go to the second-last node + temp = temp.next + temp.next = None # Remove the last node by setting the next pointer of the second-last node to None + + +### Search in a linked list + +def search(self, value): + current = self.head # Start with the head of the list + position = 0 # Counter to keep track of the position + while current: # Traverse the list + if current.data == value: # Compare the list's data to the search value + return f"Value '{value}' found at position {position}" # Print the value if a match is found + current = current.next + position += 1 + return f"Value '{value}' not found in the list" + + + + + + + + + + + + + + + + + + diff --git a/contrib/ds-algorithms/index.md b/contrib/ds-algorithms/index.md index 666bcfd..4b6e20d 100644 --- a/contrib/ds-algorithms/index.md +++ b/contrib/ds-algorithms/index.md @@ -8,3 +8,4 @@ - [Searching Algorithms](searching-algorithms.md) - [Greedy Algorithms](greedy-algorithms.md) - [Dynamic Programming](dynamic-programming.md) +- [Linked list](Linked-list.md)