SYBSc(CS) PRACTICAL-1 DS

Practical-01
Title: Write a program to implement Abstract Data Types (ADT).
Programs:
from array import *

def insert(array1,index,element):
array1.insert(index,element)

def traverse(array1):
for x in array1:
print(x,end=" ")

def delete(array1,element):
array1.remove(element)

def search(array1, n, element):

for i in range(n):
if (array1[i] == element):
return i
return -1

if __name__ == '__main__':
array1 = array('i', [10,20,30,40,50])
traverse(array1)
n = len(array1)
index = int(input("\nEnter index at which element to be inserted:"))
element = int(input("\nEnter element to be inserted:"))
insert(array1,index,element)
print("Array after Insertion")
traverse(array1)
element = int(input("\nEnter element to be deleted:"))
delete(array1,element)
print("Array after deletion")
traverse(array1)
element = int(input("\nEnter element to be searched:"))
index = search(array1, n, element)
if index != -1:
print("Element Found at position: " + str(index + 1))
else:
print("Element not found")

Output:
10 20 30 40 50
Enter index at which element to be inserted:2

Enter element to be inserted:25

Array after Insertion
10 20 25 30 40 50
Enter element to be deleted:30
Array after deletion
10 20 25 40 50
Enter element to be searched:40
Element Found at position: 4

Conclusion:
 SYBSc(CS) PRACTICAL-2 DS

Practical-02
Title: Write a program to implement Singly Linked List with insertion, deletion, traversal operations.
Programs:
class Node:
def __init__(self,data):
self.data=data
self.next=None

class linkedList:
def __init__(self):
self.head=None

def insertAtBeginning(self,data):
temp=Node(data)
if self.head==None:
self.head=temp
else:
temp.next=self.head
self.head=temp

def insertAtEnd(self,data):
temp=Node(data)
if self.head==None:
self.head=temp
else:
curr=self.head
while curr.next!=None:
curr=curr.next
curr.next=temp

def insertAtGivenPosition(self,data,position):
count=1
curr=self.head
while count<position-1 and curr!=None:
curr=curr.next
count+=1
temp=Node(data)
temp.next=curr.next
curr.next=temp

def traverse(self):
curr=self.head
while curr!=None:
print(curr.data)
curr=curr.next

def delFromBeginning(self):
try:
if self.head==None:
raise Exception("Empty Linked List")
else:
temp=self.head
self.head=self.head.next
del temp
except Exception as e:
print(str(e))
SYBSc(CS) PRACTICAL-2 DS

def delFromEnd(self):
try:
if self.head==None:
raise Exception("Empty Linked List")
else:
curr=self.head
prev=None
while curr.next!=None:
prev=curr
curr=curr.next
prev.next=curr.next
del curr
except Exception as e:
print(str(e))

def delAtPos(self,position):
try:
if self.head==None:
raise Exception("Empty Linked List")
else:
curr=self.head
prev=None
count=1
while curr!=None and count<position:
prev=curr
curr=curr.next
count+=1
prev.next=curr.next
del curr
except Exception as e:
print(str(e))

l1 = linkedList()
print("Linked list before insertion")
l1.traverse()
l1.insertAtBeginning(10)
l1.insertAtBeginning(20)
print("Linked list after insertion at beginning")
l1.traverse()
l1.insertAtBeginning(30)
l1.insertAtBeginning(40)
print("Linked list after insertion")
l1.traverse()
l1.insertAtEnd(50)
print("Linked list after inserting 50 at end")
l1.traverse()
l1.insertAtBeginning(60)
print("Linked list after inserting 60 at beginning")
l1.traverse()
l1.insertAtGivenPosition(70,3)
print("Linked list after inserting 70 at position 3")
l1.traverse()
l1.delFromBeginning()
print("Linked list after deleting from beginning")
l1.traverse()
l1.delFromEnd()
print("Linked list after deleting from end")
 SYBSc(CS) PRACTICAL-2 DS
l1.traverse()
l1.delAtPos(4)
print("Linked list after deleting at position 4")
l1.traverse()

Output:
Linked list before insertion
Linked list after insertion at beginning
20
10
Linked list after insertion
40
30
20
10
Linked list after inserting 50 at end
40
30
20
10
50
Linked list after inserting 60 at beginning
60
40
30
20
10
50
Linked list after inserting 50 at position 3
60
40
70
30
20
10
50
Linked list after deleting from beginning
40
70
30
20
10
50
Linked list after deleting from end
40
70
30
20
10
Linked list after deleting at position 4
40
70
30
10

Conclusion:
 SYBSc(CS) PRACTICAL-4 DS

Practical-04

Title: Write a program to implement Stack with insertion, deletion, traversal operations.

Programs:
class Stack:
def __init__(self):
self.elements = [ ]

def push(self, data):

self.elements.append(data)
return data

def pop(self):
if stack.is_empty():
print('Stack is empty.')
else:
print('Popped value: ', self.elements[-1] )
self.elements.pop(-1)

def peek(self):
return self.elements[-1]

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

def display(self):
print(self.elements)

stack = Stack()
print(stack.is_empty())
stack.display()
print("Stack after push(1)")
stack.push(1)
print(stack.peek())
stack.display()
print("Stack after push(2)")
stack.push(2)
print(stack.peek())
stack.display()
print("Stack after push(3)")
stack.push(3)
print(stack.peek())
stack.display()
print("Stack after push(4)")
stack.push(4)
print(stack.peek())
stack.display()
print("Stack after push(5)")
stack.push(5)
print(stack.peek())
stack.display()
print(stack.is_empty())
stack.pop()
stack.display()
 SYBSc(CS) PRACTICAL-4 DS
stack.pop()
stack.display()
stack.pop()
stack.display()
stack.pop()
stack.display()
stack.pop()
stack.display()
stack.pop()
stack.display()

Output:
True
[]
Stack after push(1)
1
[1]
Stack after push(2)
2
[1, 2]
Stack after push(3)
3
[1, 2, 3]
Stack after push(4)
4
[1, 2, 3, 4]
Stack after push(5)
5
[1, 2, 3, 4, 5]
False
Popped value: 5
[1, 2, 3, 4]
Popped value: 4
[1, 2, 3]
Popped value: 3
[1, 2]
Popped value: 2
[1]
Popped value: 1
[]
Stack is empty.
[]
Conclusion:
 SYBSc(CS) PRACTICAL-3 DS

Practical-03

Title: Write a program to implement Doubly Linked list with insertion, deletion, traversal operations.

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

class DoublyLinkedList:
def __init__(self):
self.head = None

def insertAtBegin(self,data):
temp = Node(data)
if self.head == None:
self.head = temp
else:
temp.next = self.head
self.head.prev = temp
self.head = temp

def insertAtEnd(self,data):
temp = Node(data)
if self.head == None:
self.head = temp
else:
curr = self.head
while curr.next != None:
curr = curr.next
curr.next = temp
temp.prev = curr

def traverse(self):
curr = self.head
while curr != None:
print(curr.data)
curr = curr.next

def insertAtGivenPosition(self,data,position):
count = 1
curr = self.head
while count < position-1 and curr != None:
curr = curr.next
count += 1
temp = Node(data)
temp.next = curr.next
temp.next.prev = temp
curr.next = temp
temp.prev = curr

def delFromBegin(self):
try:
SYBSc(CS) PRACTICAL-3 DS
if self.head == None:
raise Exception("Empty Linked List")
else:
temp = self.head
self.head = temp.next
self.head.prev = None
temp.next = None
del temp
except Exception as e:
print(str(e))

def delFromEnd(self):
try:
if self.head == None:
raise Exception("Empty Linked List")
else:
curr = self.head
prev = None
while curr.next != None:
curr = curr.next
curr.prev.next = None
curr.prev = None
del curr
except Exception as e:
print(str(e))

def delAtPosition(self,position):
try:
if self.head == None:
raise Exception("Empty Linked List")
else:
temp = self.head
count = 1
while temp != None and count < position:
curr = temp
temp = temp.next
count += 1
curr.next = temp.next
temp.next.prev = curr
temp.next = None
temp.prev = None
del curr
except Exception as e:
print(str(e))

ll = DoublyLinkedList()
ll.insertAtBegin(10)
ll.insertAtBegin(20)
print("Doubly Linked List after insertion at beginning")
ll.traverse()
ll.insertAtBegin(30)
ll.insertAtBegin(40)
print("Doubly Linked List after insertion at beginning")
ll.traverse()
ll.insertAtEnd(50)
print("Doubly Linked List after insertion at end")
ll.traverse()
ll.insertAtBegin(60)
 SYBSc(CS) PRACTICAL-3 DS
print("Doubly Linked List after insertion at beginning")
ll.traverse()
ll.insertAtGivenPosition(70,3)
print("Doubly Linked List after insertion at position 3")
ll.traverse()
ll.delFromBegin()
print("Doubly Linked List after deletion from beginning")
ll.traverse()
ll.delFromEnd()
print("Doubly Linked List after deletion from end")
ll.traverse()
ll.delAtPosition(4)
print("Doubly Linked List after deletion at position 4")
ll.traverse()

Output:
Doubly Linked List after insertion at beginning
20
10
Doubly Linked List after insertion at beginning
40
30
20
10
Doubly Linked List after insertion at end
40
30
20
10
50
Doubly Linked List after insertion at beginning
60
40
30
20
10
50
Doubly Linked List after insertion at position 3
60
40
70
30
20
10
50
Doubly Linked List after deletion from beginning
40
70
30
20
10
50
Doubly Linked List after deletion from end
40
70
30
20
10
SYBSc(CS) PRACTICAL-3 DS
Doubly Linked List after deletion at position 4
40
70
30
10

Conclusion:
 SYBSc(CS) PRACTICAL-6 DS

Practical-06
Title: Write a program to implement Priority Queue with insertion, deletion, traversal operations.
Programs:
class PriorityQueue(object):
def __init__(self):
self.queue = []

def __str__(self):
return ' '.join([str(i) for i in self.queue])

# for checking if the queue is empty

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

# for inserting an element in the queue

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

# for popping an element based on Priority

def delete(self):
try:
max_val = 0
for i in range(len(self.queue)):
if self.queue[i] > self.queue[max_val]:
max_val = i
item = self.queue[max_val]
del self.queue[max_val]
return item
except IndexError:
print()
exit()

if __name__ == '__main__':
myQueue = PriorityQueue()
print("Queue before insertion")
print(myQueue)
myQueue.insert(12)
myQueue.insert(1)
myQueue.insert(14)
myQueue.insert(7)
print("Queue after insertion")
print(myQueue)
while not myQueue.isEmpty():
print("Queue deleted item based on priority")
print(myQueue.delete())

Output:
Queue before insertion

Queue after insertion

12 1 14 7
Queue deleted item based on priority
14
Queue deleted item based on priority
12
Queue deleted item based on priority
SYBSc(CS) PRACTICAL-6 DS
7
Queue deleted item based on priority
1

Conclusion:
 SYBSc(CS) PRACTICAL-5 DS

Practical-05

Title: Write a program to implement Queue with insertion, deletion, traversal operations.

Programs:
class Queue:
def __init__(self):
self.queue = []

def enqueue(self, item):

self.queue.append(item)

def dequeue(self):
if len(self.queue) < 1:
return None
return self.queue.pop(0)

def display(self):
print(self.queue)

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

q = Queue()
print("Before inserting an element")
q.display()
q.enqueue(1)
print("After inserting an element(1)")
q.display()
q.enqueue(2)
print("After inserting an element(2)")
q.display()
q.enqueue(3)
print("After inserting an element(3)")
q.display()
q.enqueue(4)
print("After inserting an element(4)")
q.display()
q.enqueue(5)
print("After inserting an element(5)")
q.display()

q.dequeue()
print("After removing an element")
q.display()
q.dequeue()
print("After removing an element")
q.display()
q.dequeue()
print("After removing an element")
q.display()
 SYBSc(CS) PRACTICAL-5 DS
Output:
Before inserting an element
[]
After inserting an element(1)
[1]
After inserting an element(2)
[1, 2]
After inserting an element(3)
[1, 2, 3]
After inserting an element(4)
[1, 2, 3, 4]
After inserting an element(5)
[1, 2, 3, 4, 5]
After removing an element
[2, 3, 4, 5]
After removing an element
[3, 4, 5]
After removing an element
[4, 5]

Conclusion:
 SYBSc(CS) PRACTICAL-8 DS

Practical-08
Title: Write a program to implement Travelling Salesman Problem.
Programs:
from sys import maxsize
from itertools import permutations
V=4

def travellingSalesmanProblem(graph, s):

vertex = []
for i in range(V):
if i != s:
vertex.append(i)

min_path = maxsize

next_permutation=permutations(vertex)
for i in next_permutation:
print(i)
current_pathweight = 0
k=s
for j in i:
current_pathweight += graph[k][j]

k=j
current_pathweight += graph[k][s]
print(current_pathweight)
min_path = min(min_path, current_pathweight)

return min_path

if __name__ == "__main__":
graph = [[0, 10, 15, 20], [10, 0, 35, 25],
[15, 35, 0, 30], [20, 25, 30, 0]]
s=0
print("Minimum cost is:",travellingSalesmanProblem(graph, s))

Output:
(1, 2, 3)
95
(1, 3, 2)
80
(2, 1, 3)
95
(2, 3, 1)
80
(3, 1, 2)
95
(3, 2, 1)
95
Minimum cost is: 80

Conclusion:
 SYBSc(CS) PRACTICAL-9 DS

Practical-09
Title: Write a program to create basic Hash Table for insertion, deletion, traversal operations.
Programs:
hash_table = [[] for _ in range(10)]
print (hash_table)

def insert(hash_table, key, value):

hash_key = hash(key) % len(hash_table)
key_exists = False
bucket = hash_table[hash_key]
for i, kv in enumerate(bucket):
k, v = kv
if key == k:
key_exists = True
break
if key_exists:
bucket[i] = ((key, value))
else:
bucket.append((key, value))

def search(hash_table, key):

hash_key = hash(key) % len(hash_table)
bucket = hash_table[hash_key]
for i, kv in enumerate(bucket):
k, v = kv
if key == k:
return v

def delete(hash_table, key):

hash_key = hash(key) % len(hash_table)
key_exists = False
bucket = hash_table[hash_key]
for i, kv in enumerate(bucket):
k, v = kv
if key == k:
key_exists = True
break
if key_exists:
del bucket[i]
print ('Key {} deleted'.format(key))
else:
print ('Key {} not found'.format(key))

insert(hash_table, 10, 'Nepal')

insert(hash_table, 25, 'USA')
insert(hash_table, 20, 'India')
print (hash_table)

print (search(hash_table, 10))

print (search(hash_table, 20))
print (search(hash_table, 30))

delete(hash_table, 100)
print (hash_table)
 SYBSc(CS) PRACTICAL-9 DS
delete(hash_table, 20)
print (hash_table)

Output:
[[], [], [], [], [], [], [], [], [], []]
[[(10, 'Nepal'), (20, 'India')], [], [], [], [], [(25, 'USA')], [], [], [], []]
Nepal
India
None
Key 100 not found
[[(10, 'Nepal'), (20, 'India')], [], [], [], [], [(25, 'USA')], [], [], [], []]
Key 20 deleted
[[(10, 'Nepal')], [], [], [], [], [(25, 'USA')], [], [], [], []]

Conclusion:
 SYBSc(CS) PRACTICAL-10 DS

Practical-10
Title: Write a program to create hash table to handle collisions using overflow chaining.
Programs:
# Function to display hashtable
def display_hash(hashTable):

for i in range(len(hashTable)):
print(i, end = " ")

for j in hashTable[i]:
print("-->", end = " ")
print(j, end = " ")

print()

# Creating Hashtable as a nested list.

HashTable = [[] for _ in range(10)]

# Hashing Function to return key for every value.

def Hashing(keyvalue):
return keyvalue % len(HashTable)

# Insert Function to add values to the hash table

def insert(Hashtable, keyvalue, value):

hash_key = Hashing(keyvalue)
Hashtable[hash_key].append(value)

# Driver Code
insert(HashTable, 10, 'Allahabad')
insert(HashTable, 25, 'Mumbai')
insert(HashTable, 20, 'Mathura')
insert(HashTable, 9, 'Delhi')
insert(HashTable, 21, 'Punjab')
insert(HashTable, 21, 'Noida')

display_hash (HashTable)

Output:
0 --> Allahabad --> Mathura
1 --> Punjab --> Noida
2
3
4
5 --> Mumbai
6
7
8
9 --> Delhi

Conclusion: