Linked lists are a dynamic data structure that stores elements sequentially in memory. Each element contains a data field and a pointer to the next element. Elements can easily be inserted or removed without rearranging other elements. While random access is not possible, linked lists use less memory than arrays and are dynamic in size. Common linked list operations include insertion, deletion, search, and traversal.

1. Linked List
1

2. • A linked list is a sequence of data elements,
which are connected together via links. Each
data element contains a connection to
another data element in form of a pointer.
2

3. • A linked list is a data structure which can change
during execution.
– Successive elements are connected by pointers.
– Last element points to NULL.
– It can grow or shrink in size during execution of a
program.
– It does not waste memory space.
Why Linked List?
• The size of the arrays is fixed
• Insertion / Deletion of an element in an is
expensive.
3

4. Advantages of Linked Lists over arrays:
• Dynamic Array.
• Ease of Insertion/Deletion.
Drawbacks of Linked Lists:
• Random access is not allowed. We have to access elements
sequentially.
• Extra memory space for a pointer is required with each
element of the list.
• Basic operations on Linked Lists:
• Display
• Insertion
• Deletion
• Search
4

5. Function to initialize the node
object
class Node:
def __init__(self,data):
self. data=data
self.ref=None # next as null
Programming and Data Structure 5

6. Creating single linked list
6

7. Displaying the list
def display_list(self):
if self.head is None:
print("Empty List")
else:
print("Elements in the list are: ")
p=self.head
while p is not None:
print(p.data,"-->",end='')
p=p.ref
print() 7

8. Searching a List
def search(self, x):
p=self.head
position=1
while p is not None:
if p.data==x:
print("Found element =",x," At position = ",position)
return True
else:
p=p.ref
position+=1
print("Could not find element =",x)
return False
8

9. Insert at beginning
def insert_at_beginning(self,data):
temp=Node(data)
temp.ref=self.head
self.head=temp
9

10. Insert at end
def insert_at_end(self,data):
temp=Node(data)
# Case of empty list
if self.head is None:
self.head=temp
return
## Non-empty list, first traverse the list
p=self.head
while p.ref is not None:
p=p.ref
#Now p is pointing to last node in the list
p.ref=temp
10

11. Insert at position
def insert_at_position(self,data,k):
if k==1:
temp=Node(data)
temp.ref=self.head
self.head=temp
return
## Need to find position before k
p=self.head
i=1
while i < k-1 and p is not None:
p=p.ref
i+=1
if p is None: ## outside list bounds
print("you cannot insert beyond position index ",i)
else:
temp=Node(data)
temp.ref=p.ref
p.ref=temp 11

12. : Insertion
12
A
A
Item to be
inserted
X
X
A B C
B C
curr
tmp

13. def delete_node(self,del_element):
if self.head is None: #Case of Empty List
print("Empty List!")
return
# Case first node contain value
"del_element"
if self.head.data==del_element:
self.head=self.head.ref
return
13

14. ## Traverse list up until predecessor of node containing
"del_element"
p=self.head
while p.ref is not None:
if p.ref.data==del_element: # Check if next cell contain
"del_element"
break
p=p.ref
if p.ref is None:
print("Element ",del_element, "is not in the list")
else:
p.ref=p.ref.ref
14

15. Illustration: Deletion
Spring 2012 Programming and Data Structure 15
A B
A B C
C
Item to be deleted
curr
tmp

16. Stacks:
• #Python code to demonstrate Implementing
stack using list
stack = ["Amar", "Akbar", "Anthony"] stack.append("Ram")
stack.append("Iqbal")
print(stack)
print(stack.pop())
print(stack)
print(stack.pop())
print(stack)
16

17. Stack Using Linked List
17
Stack Operations:
1. push() : Insert the element into
linked list nothing but which is
the top node of Stack.
2. pop() : Return top element
from the Stack and move the top
pointer to the second node of
linked list or Stack.
3. peek(): Return the top element.
4. display(): Print all element of
Stack.

18. IS_EMPTY(S)
if S.top == null
return TRUE
return FALSE
18

19. Queue
• A queue follows FIFO (First-in, First out) policy.
It is equivalent to the queues in our general
life. For example, a new person enters a queue
at the last and the person who is at the front
(who must have entered the queue at first)
will be served first.
19

20. • Enqueue → Enqueue is an operation which
adds an element to the queue.
• Dequeue → it returns and deletes the front
element from the queue.
• isEmpty → It is used to check whether the
queue has any element or not.
• isFull → It is used to check whether the queue
is full or not.
• Front → it returns the front element of the
queue (but don’t delete it).
20