***LinkedList***

class Node:
def __init__(self,data=None):
self.data=data
self.next=None
class Linkedlist:
def __init__(self):
self.head=None

def insert_at_beginning(self,data):
new_node=Node(data)
if self.head==None:
self.head=new_node
print("node is inserted at begining if no node is present initially")
else:
new_node.next=self.head
self.head=new_node
print("node is inserted at the begining if already an initial node exists")

def insertion_at_end(self,data):
new_node=Node(data)
cur=self.head
while cur.next!=None:
cur=cur.next
cur.next=new_node
def insert_after_node(self,key,value):
cur=self.head
while cur!=None:
 if(cur.data==key):
break
cur=cur.next
if cur is None:
return self.head
new_node=Node(value)
new_node.next=cur.next
cur.next=new_node
return self.head

def insertion_at_position(self,pos,value,size):
if pos<1 or pos>size+1:
print("insertion is not possible")
return self.head
else:
new_node=Node(value)
if pos==1:
self.head.next=new_node.next
self.head=new_node
else:
cur=self.head
for _ in range(1,pos-1):
cur=cur.next
new_node.next=cur.next
cur.next=new_node
size+=1
return self.head
def insert_at_end(self,data):
new_node=Node(data)
cur=self.head
while cur!=None:
cur=cur.next
cur.next=new_node

def find_length(self):
count=0
cur=self.head
while cur!=None:
cur=cur.next
count+=1
print(count)

def search(self,key):
cur=self.head
while cur!=None:
if cur.data==key:
return True
cur=cur.next
return False

def del_at_first(self):
if self.head is None:
return None
self.head=self.head.next
def del_at_specific(self,position):
temp=self.head
prev=None
if temp is None:
return self.head
if position==1:
self.head=temp.next
return self.head
for i in range(1,position):
prev=temp
temp=temp.next
if temp is None:
return self.head
if temp is not None:
prev.next=temp.next
return self.head

def del_at_end(self):
if not self.head:
return None
if not self.head.next:
return None
second_last=self.head
while second_last.next.next:
second_last=second_last.next
second_last.next=None
return self.head
 def reverse(self):
cur=self.head
prev=None
while cur!=None:
next_node=cur.next
cur.next=prev
prev=cur
cur=next_node
self.head=prev

def display(self):
elems=[]
cur_node=self.head
while cur_node!=None:
elems.append(cur_node.data)
cur_node=cur_node.next
print(elems)

l=Linkedlist()
l.insert_at_beginning(2)
l.insert_at_beginning(1)
l.insertion_at_end(4)
l.insert_after_node(2,3)
l.insertion_at_position(3,5,4)
l.insertion_at_end(6)
l.display()
l.find_length()
print(l.search(5))
new_head=l.del_at_first()
print(new_head)
l.display()
l.del_at_specific(3)
l.display()
l.del_at_end()
l.display()
l.reverse()
l.display()

Output:
node is inserted at begining if no node is present initially
node is inserted at the begining if already an initial node exists
[1, 2, 5, 3, 4, 6]
6
True
None
[2, 5, 3, 4, 6]
[2, 5, 4, 6]
[2, 5, 4]
[4, 5, 2]
** Process exited - Return Code: 0 **
Press Enter to exit terminal

DoubleLinkedlist:
class Node:
def __init__(self,data):
self.data=data
self.prev=None
self.next=None
class DoubleLinked:
def __init__(self):
self.head=None

def insert_at_beginning(self,data):
new_node=Node(data)
new_node.next=self.head
if self.head is not None:
self.head.prev=new_node
self.head=new_node
return self.head

def insert_at_end(self,data):
new_node=Node(data)
if self.head is None:
self.head=new_node
else:
cur=self.head
while cur.next is not None:
cur=cur.next
cur.next=new_node
new_node.prev=cur
 return self.head
def insert_at_pos(self,pos,data):
new_node=Node(data)
count=0
cur=self.head
while cur.next!=None:
if(count==pos):
new_node.prev=cur
new_node.next=cur.next
cur.next.prev=new_node
cur.next=new_node
return head
count=count+1
cur=cur.next
if cur.next==None and count==pos:
cur.next=new_node
new_node.prev=cur
return self.head

def display(self):#forward_traversal
elems=[]
cur=self.head
while cur!=None:
elems.append(cur.data)
cur=cur.next
return elems

def backward(self):
 elems=[]
cur=self.head
while cur!=None and cur.next!=None:
cur=cur.next
while cur!=None:
elems.append(cur.data)
cur=cur.prev
return elems

def length(self):
count=0
cur=self.head
while cur!=None:
count+=1
cur=cur.next
return count

def del_beginning(self):
if not self.head:
return
self.head=self.head.next
if self.head is not None:
self.head.prev=None
return self.head

def del_at_end(self):
if not self.head:
 return
if self.head is None:
return None
cur=self.head
while cur.next!=None:
cur=cur.next
cur.prev.next=None
return self.head

def del_at_specific(self,pos):
if not self.head:
return
cur=self.head

for i in range(1,pos):
if cur==None:
break
cur=cur.next

if cur is None:
return self.head

if cur.prev is not None:

cur.prev.next=cur.next

if cur.next is not None:

cur.next.prev=cur.prev
 if self.head == cur:
self.head=cur.next

cur=None
return self.head

def search_ele(self,val):
cur=self.head
while cur!=None:
if cur.data==val:
return True
cur=cur.next
return False

dl=DoubleLinked()
dl.insert_at_beginning(1)
print(dl.display())
dl.insert_at_end(2)
dl.insert_at_end(3)
dl.insert_at_end(4)
dl.insert_at_end(5)
print(dl.display())
dl.insert_at_pos(4,6)
print(dl.display())
print(dl.backward())
print(dl.length())
dl.del_beginning()
print(dl.display())
dl.del_at_end()
print(dl.display())
dl.del_at_specific(2)
print(dl.display())
print(dl.search_ele(6))

[1]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6]
[6, 5, 4, 3, 2, 1]
6
[2, 3, 4, 5, 6]
[2, 3, 4, 5]
[2, 4, 5]
False
** Process exited - Return Code: 0 **
Press Enter to exit terminal

***Stack***
class Stack:

def __init__(self):
self.stack=[]

def is_empty(self):
return len(self.stack)==0
 def push(self,data):
self.stack.append(data)

def pop(self):
if self.is_empty():
raise IndexError("stack is empty we cannot pop")
return self.stack.pop()

def peek(self):
if self.is_empty():
raise IndexError("stack is empty")
return self.stack[-1]

def size(self):
return len(self.stack)

def __str__(self):
return str(self.stack)

# Example usage
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
print("Stack:", stack)
print("Pop:", stack.pop())
print("Peek:", stack.peek())
print("Size:", stack.size())
print("Is empty:", stack.is_empty())

***stack implementation using linkedlist**

#implementing stack using linkedlist:

class Node:

def __init__(self,data):
self.data=data
self.next=None

class Stack:

def __init__(self):
self.head=None

def is_empty(self):
return self.head is None

def push(self,data):
new_node=Node(data)

if not new_node:
print("\n stack overflow")
return
new_node.next=self.head
 self.head=new_node

def pop(self):

if self.is_empty():
print("\n stack underflow")
else:
temp=self.head
self.head=self.head.next
del temp

def peek(self):

if not self.is_empty():
return self.head.data

else:
print("\n stack is empty")
return float('-inf')

st=Stack()
st.push(1)
st.push(2)
st.push(3)
st.push(4)

print("top element is",st.peek())

st.pop()
print("top element is",st.peek())

**Queue data structure**:

class Queue:

def __init__(self):
self.queue=[]

def is_empty(self):
return len(self.queue)==0

def enqueue(self,data):
self.queue.append(data)

def dequeue(self):

if self.is_empty():
raise IndexError("queue is empty")

return self.queue.pop(0)

def length(self):
return len(self.queue)

def peek(self):
 if self.is_empty():
raise IndexError("Queue is empty")
return self.queue[0]

def __str__(self):
return str(self.queue)

qe=Queue()
qe.enqueue(1)
qe.enqueue(2)
qe.enqueue(3)
qe.enqueue(4)
qe.enqueue(5)

print("queue :", qe)

print("Dequeue : ",qe.dequeue())

print("length : ", qe.length())

print("peek : ", qe.peek())

print("queue :", qe)

***Queue using Linkedlist***

class Node:
 def __init__(self,data):
self.data=data
self.next=None
class Queue:

def __init__(self):
self.front=None
self.rear=None

def is_empty(self):
return self.front is None and self.rear is None

def enqueue(self,data):
new_node=Node(data)
if self.rear is None:
self.rear=self.front=new_node
return

self.rear.next=new_node
self.rear=new_node

def dequeue(self):
if self.is_empty():
print("\n Queue is empty")
return
temp=self.front
self.front=self.front.next
 if self.front is None:
self.rear=None

def get_front(self):
if self.is_empty():
print("\n Queue is empty")
return float('-inf')
return self.front.data

def get_rear(self):
if self.is_empty():
print("\n queue is empty")
return float('-inf')
return self.rear.data

q = Queue()

# Enqueue elements into the queue

q.enqueue(10)
q.enqueue(20)

# Display the front and rear elements of the queue

print("Queue Front:", q.get_front())
print("Queue Rear:", q.get_rear())

# Dequeue elements from the queue

q.dequeue()
q.dequeue()
# Enqueue more elements into the queue
q.enqueue(30)
q.enqueue(40)
q.enqueue(50)

# Dequeue an element from the queue

q.dequeue()

# Display the front and rear elements of the queue

print("Queue Front:", q.get_front())
print("Queue Rear:", q.get_rear())

**Tree Implementation**
# Tree traversal in Python

class Node:
def __init__(self, item):
self.left = None
self.right = None
self.val = item

def inorder(root):

if root:
 # Traverse left
inorder(root.left)
# Traverse root
print(str(root.val) + "->", end='')
# Traverse right
inorder(root.right)

def postorder(root):

if root:
# Traverse left
postorder(root.left)
# Traverse right
postorder(root.right)
# Traverse root
print(str(root.val) + "->", end='')

def preorder(root):

if root:
# Traverse root
print(str(root.val) + "->", end='')
# Traverse left
preorder(root.left)
# Traverse right
preorder(root.right)
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)

print("Inorder traversal ")

inorder(root)

print("\nPreorder traversal ")

preorder(root)

print("\nPostorder traversal ")

postorder(root)

**Binary Search Tree Implementation**

class TreeNode:
def __init__(self,data):
self.data=data
self.left=None
self.right=None
class BinarySearchTree:
def __init__(self):
self.root=None
def insert(self,data):
if self.root is None:
self.root=TreeNode(data)
return
self._insert(self.root,data)

def _insert(self,node,data):
if data < node.data:
if node.left is None:
node.left=TreeNode(data)
else:
self._insert(node.left,data)
else:
if node.right is None:
node.right=TreeNode(data)
else:
self._insert(node.right,data)

def inorder(self):
nodes=[]
self._inorder(self.root,nodes)
return nodes

def _inorder(self,node,nodes):
if node is not None:
self._inorder(node.left,nodes)
nodes.append(node.data)
self._inorder(node.right,nodes)
def preorder(self):
nodes=[]
self._preorder(self.root,nodes)
return nodes

def _preorder(self,node,nodes):
if node is not None:
nodes.append(node.data)
self._preorder(node.left,nodes)
self._preorder(node.right,nodes)

def postorder(self):
nodes=[]
self._postorder(self.root,nodes)
return nodes

def _postorder(self,node,nodes):
if node is not None:
self._postorder(node.left,nodes)
self._postorder(node.right,nodes)
nodes.append(node.data)

def find(self,data):
return self._find(self.root,data)

def _find(self,node,data):
if node is None:
 return False
if data==node.data:
return True
elif data<node.data:
return self._find(node.left,data)
else:
return self._find(node.right,data)

bst=BinarySearchTree()
bst = BinarySearchTree()
bst.insert(10)
bst.insert(5)
bst.insert(20)
bst.insert(3)
bst.insert(7)
bst.insert(15)
bst.insert(30)
print("Inorder traversal:", bst.inorder())
print("Preorder Traversal:",bst.preorder())
print("Postorder Traversal:",bst.postorder())
print("Element is present:",bst.find(15))
*** DFS Tree Traversal***
# Python3 program to for tree traversals

# A class that represents an individual node in a

# Binary Tree

class Node:
def __init__(self, key):
self.left = None
self.right = None
self.val = key

# A function to do inorder tree traversal

def printInorder(root):

if root:

# First recur on left child

printInorder(root.left)

# then print the data of node

print(root.val),

# now recur on right child

 printInorder(root.right)

# A function to do postorder tree traversal

def printPostorder(root):

if root:

# First recur on left child

printPostorder(root.left)

# the recur on right child

printPostorder(root.right)

# now print the data of node

print(root.val),

# A function to do preorder tree traversal

def printPreorder(root):

if root:

# First print the data of node

print(root.val),

# Then recur on left child

printPreorder(root.left)
 # Finally recur on right child
printPreorder(root.right)

# Driver code
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
print "Preorder traversal of binary tree is"
printPreorder(root)

print "\nInorder traversal of binary tree is"

printInorder(root)

print "\nPostorder traversal of binary tree is"

printPostorder(root)