P

ractical no.01

Q.1: Write a program to implement Abstract Data Type (ADT)

1. Using Built in Data Type (List)

A) Code:-

list1 = [10,20,30,40,50]
print("printing element in python by using different
ways") print("Print list by print()method",list1)

print("print list by for

loop") for i in list1:

print(i,end="")
print()
print("print list by*

asterisk") print(*list1)

print("print list by comma

separator") print(list1,sep=",")

Output:-

printing element in python by using different

ways Print list by print()method [10, 20, 30, 40,

50] print list by for loop

1020304050

print list by*

asterisk 10 20 30 40

50
print list by comma

separator [10, 20, 30, 40, 50]

 B) Code:-

list1 = [10,20,30,40,50]
print(list1[0])
print(list1[1:4]
)
print(list1[1:3]
) print(list1[-
1])
print(list1[3:-1])
print(list1[0:2:2])
print(list1[0:5])

Output:-

10
[20, 30, 40]

[20, 30]

50
[40]

[10]
[10, 20, 30, 40, 50]

C) Code:-

le = [10,20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200]

print("printing the list element using print:\

n",le) print("printing the list element using for

loop:") for i in le:

print(i,end=" ")
print("\nprinting the list element *
asterisk:") print(*le)
print("printing the list element by comma separator:")
print(le,sep=",")

Output:-

printing the list element using print:

[10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200]

printing the list element using for loop:

10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160 170 180 190 200
printing the list element * asterisk:

10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160 170 180 190 200
printing the list element by comma separator:

[10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200]

D) Code:-

le = [10,20,30,40,50]
print(le)

print(le[1::])

print(le[1:3])

print(le[4:])

print(le[3::])
print(le[::2])

print(le[::4])
print("printing in
reverse") print((le[::-1]))

print(le[-1:-5:-1])
print(le[-3:-5:-1])
print(le[4::])
print(le[::-1])

print(le[::2])
print(le[::4])

Output:-

[10, 20, 30, 40, 50] [20,

30, 40, 50]

[20, 30]

[50]

[40, 50]
[10, 30, 50]

[10, 50]
printing in reverse
[50, 40, 30, 20, 10]
[50, 40, 30, 20]
[30, 20]

[50]
[50, 40, 30, 20, 10]

[10, 30, 50]

[10, 50]

2. Using modules numpy

A) Code:-
import numpy as np
from numpy import*
a=np.array([["Mon",1,2,3,4],["Tue",5,6,7,8],["Wed",9,10,11,12],["Thu",13,14,15,16],["Fri",17,18
,19,20],["Sat",21,22,23,24]])

m = reshape(a,(6,5))

#printing array

print(m,end="")
 Output:-

[['Mon' '1' '2' '3' '4']

['Tue' '5' '6' '7' '8']

['Wed' '9' '10' '11' '12']

['Thu' '13' '14' '15' '16']

['Fri' '17' '18' '19' '20']

['Sat' '21' '22' '23' '24']]

B) Code:-

import numpy as np

from numpy import*

a=np.array([["Mon",1,2,3,4],["Tue",5,6,7,8],["Wed",9,10,11,12],["Thu",13,14,15,16],["Fri",17,18
,19,20],["Sat",21,22,23,24]])

m = reshape(a,(6,5))

#printing array

print(m[2])

Output:-

['Wed' '9' '10' '11' '12']

C) Code:-

import numpy as np

from numpy import*

a=np.array([["Mon",1,2,3,4],["Tue",5,6,7,8],["Wed",9,10,11,12],["Thu",13,14,15,16],["Fri",17,18
,19,20],["Sat",21,22,23,24]])

m = reshape(a,(6,5))

#printing array

print(m,end="")
r = append(m,["Sun",25,26,27,28])
print(r)
Output:-

[['Mon' '1' '2' '3' '4']

['Tue' '5' '6' '7' '8']

['Wed' '9' '10' '11' '12']

['Thu' '13' '14' '15' '16']

['Fri' '17' '18' '19' '20']

['Sat' '21' '22' '23' '24']]['Mon' '1' '2' '3' '4' 'Tue' '5' '6' '7' '8' 'Wed' '9' '10' '11' '12'
'Thu' '13' '14' '15' '16' 'Fri' '17' '18' '19' '20' 'Sat' '21' '22' '23'

'24' 'Sun' '25' '26' '27' '28']

D) Code:-

import numpy as np
from numpy import*
a=np.array([["Mon",1,2,3,4],["Tue",5,6,7,8],["Wed",9,10,11,12],["Thu",13,14,15,16],["Fri",17,18
,19,20],["Sat",21,22,23,24]])

m = reshape(a,(6,5))

d = np.delete(m,[3],0)
print(d,end="")
Output:-

[['Mon' '1' '2' '3' '4']

['Tue' '5' '6' '7' '8']

['Wed' '9' '10' '11' '12']

['Fri' '17' '18' '19' '20']

['Sat' '21' '22' '23' '24']]

E) Code:-

import numpy as np
from numpy import*

a=np.array([["Mon",1,2,3,4],["Tue",5,6,7,8],["Wed",9,10,11,12],["Thu",13,14,15,16],["Fri",17,18
,19,20],["Sat",21,22,23,24]])

m = reshape(a,(6,5))

print(m)

#Printing array

r = append(m,["Sun",25,26,27,28])
print(r)
d = np.delete(r,
[3],0) print(d)

print(a[2])

Output:-

[['Mon' '1' '2' '3' '4']

['Tue' '5' '6' '7' '8']

['Wed' '9' '10' '11' '12']

['Thu' '13' '14' '15' '16']

['Fri' '17' '18' '19' '20']

['Sat' '21' '22' '23' '24']]

['Mon' '1' '2' '3' '4' 'Tue' '5' '6' '7' '8' 'Wed' '9' '10' '11' '12'

'Thu' '13' '14' '15' '16' 'Fri' '17' '18' '19' '20' 'Sat' '21' '22' '23'

'24' 'Sun' '25' '26' '27' '28']

['Mon' '1' '2' '4' 'Tue' '5' '6' '7' '8' 'Wed' '9' '10' '11' '12' 'Thu'

'13' '14' '15' '16' 'Fri' '17' '18' '19' '20' 'Sat' '21' '22' '23' '24'
'Sun' '25' '26' '27' '28']

['Wed' '9' '10' '11' '12']

F) Code:-
import numpy as np
from numpy import*

a=np.array([["Mon",1,2,3,4],["Tue",5,6,7,8],["Wed",9,10,11,12],["Thu",13,14,15,16],["Fri",17,18
,19,20],["Sat",21,22,23,24]])

print(a)

a[3] = ["N/a",0,0,0,0]

print(a)

Output:-

[['Mon' '1' '2' '3' '4']

['Tue' '5' '6' '7' '8']

['Wed' '9' '10' '11' '12']

['Thu' '13' '14' '15' '16']

['Fri' '17' '18' '19' '20']

['Sat' '21' '22' '23' '24']]

[['Mon' '1' '2' '3' '4']

['Tue' '5' '6' '7' '8']

['Wed' '9' '10' '11' '12']

['N/a' '0' '0' '0' '0']

['Fri' '17' '18' '19' '20']

['Sat' '21' '22' '23'

'24']]
 P
ractical No.02

Q. Write a program to implement Single Linked List with insertion, deletion,

traversal operations.

Code:-

class Node:
def init (self, data, next=None):
self.dataVal = data
self.nextVal = next
class SingleLinkList:

def init (self, head=None):

self.headVal = head
def listprint(self):

printval = self.headVal
while printval is not None:

print(printval.dataVal, end=",
") printval = printval.nextVal
def insertAtBeginning(self,
newdata): NewNode =
Node(newdata) NewNode.nextVal =
self.headVal self.headVal =
NewNode
def insertAtEnd(self,
newdata): NewNode =
Node(newdata)
if self.headVal is None:
self.headVal =
NewNode return
laste = self.headVal
while
laste.nextVal:
laste.nextVal = NewNode

def insertInBetween(self, middle_node,

newdata): if middle_node is None:

print("The mentioned node is

absent") return

NewNode = Node(newdata)

NewNode.nextVal = middle_node.nextVal

middle_node.nextVal = NewNode

def removeNode(self, Removekey):

HeadVal =
self.headVal if
HeadVal is not None:

if HeadVal.dataVal == Removekey:
self.headVal = HeadVal.nextVal
HeadVal
= None

return

while HeadVal is not None:

if HeadVal.dataVal == Removekey: break

prev = HeadVal

HeadVal = HeadVal.nextVal

if HeadVal is None:

return
prev.nextVal =
HeadVal.nextVal HeadVal =
None
def removeStart(self):
if self.headVal is not None:
self.headVal = self.headVal.nextVal
def
removeEnd(self):

last =

self.headVal
if last is None:

print("List is empty")

return

if last.nextVal is None:

self.headVal =
None return None
while last.nextVal.nextVal:

last = last.nextVal
if last.nextVal.nextVal is None:
last.nextVal = None

# Test the corrected

code sli = SingleLinkList()

e1 = Node("Mon")
e2 = Node("Tue")
e3 = Node("Wed")
e4 = Node("Thu")
e5 = Node("Fri")
sli.headVal = e1
e1.nextVal = e2
e2.nextVal = e3
e3.nextVal = e4
e4.nextVal = e5
print("*** Printing Link List

***") sli.listprint()

print("\n*** Printing Link List After Inserting At Beginning

***") sli.insertAtBeginning("Sun")

sli.listprint()
print("\n*** Printing Link List After Inserting At End
***") sli.insertAtEnd("Sat")

sli.listprint()

print("\n*** Printing Link List After Inserting In Between

***") sli.insertInBetween(e3, "n/a")

sli.listprint()

print("\n*** Printing Link List After Removing Element In Between

***")

sli.removeNode("n/a")

sli.listprint()

print("\n*** Printing Link List After Removing Element At Beginning ***")

sli.removeStart()

sli.listprint()

print("\n*** Printing Link List After Removing Element At End

***")

sli.removeEnd()

sli.listprint()

Output:-

*** Printing Link List ***

Mon, Tue, Wed, Thu, Fri,
*** Printing Link List After Inserting At Beginning ***

Sun, Mon, Tue, Wed, Thu, Fri,

*** Printing Link List After Inserting At End ***

Sun, Mon, Tue, Wed, Thu, Fri, Sat,
*** Printing Link List After Inserting In Between

*** Sun, Mon, Tue, Wed, n/a, Thu, Fri, Sat,

*** Printing Link List After Removing Element In Between
*** Sun, Mon, Tue, Wed, Thu, Fri, Sat,

*** Printing Link List After Removing Element At Beginning

*** Mon, Tue, Wed, Thu, Fri, Sat,

*** Printing Link List After Removing Element At End

*** Mon, Tue, Wed, Thu, Fri,
 P
ractical No. 03

Q. Write a program to implement a Double Linked list with insertion, deletion,

traversal operations.

Code:-

#node structure
class Node:
# constructor to create a new

node def init (self, data):

self.data = data
self.next = None
self.prev = None
# class Linked
List class
LinkedList:
# constructor to create an empty

LinkedList def init (self):

self.head =
None # test the
code
# create an empty
LinkedList MyList =
LinkedList()
# Add first node.
first = Node(10)
# linking with head node
MyList.head = first
# Add second node.

second = Node(20)

# linking with first node

second.prev = first
first.next =

second # Add third

node. third =

Node(30)

# linking with second node

third.prev = second
second.next = third
# Function to print the linked list def
print_linked_list(linked_list):
current = linked_list.head while
current is not None:
print(current.data, end=" -> ")
current = current.next
print("None")

# Print the linked list

print("Linked List:")

print_linked_list(MyList

Output:-

10 ->; 20 ->; 30 ->; None

 P
ractical No.04

Q.4: write a program to implement stack with insertion, deletion,traversal

operations 1.Using list

A) Code:-

stack=[]

stack.append(10) #append method is used to push the

element stack.append(20)

stack.append(300)
print(stack)
stack.pop() #the pop method is used to remove the

element print(stack)

print("no.of element in

stack:-",len(stack)) stack.pop()

stack.pop()

Output:-

[10, 20, 300]

[10, 20]
no.of element in stack:- 2

2. Using modules

A) Code:-

import collections
stack=collections.deque()
stack.append(10)
stack.append(3.14)
stack.append("value of p1")
stack.append("value of
radius") stack.append(10)
stack.append(10)
print(stack)

print("no of element in deque:-",len(stack)) #return the number of items in a

stack print("count 10 in deque:-",stack.count(10))

Output:-

deque([10, 3.14, 'value of p1', 'value od radius', 10,

10]) no of element in deque:- 6

count 10 in deque:- 3

B) Code:-

import queue
stack=queue.LifoQueue()
stack.put(10)
stack.put(200)
stack.put("SYBSCCS
Class")
print("check stack is empty or
not:-",stack.empty()) print("check stack is full or
not:-",stack.full()) print("no.of the item in
lifoqueue:-",stack.qsize())
print("element:-",stack.get())
print("element:-",stack.get())

print("element:-",stack.get())

print("check stack is empty or not:-",stack.empty())

Output:-
check stack is empty or not:-
False check stack is full or not:-
False no.of the item in
lifoqueue:- 3 element:- SYBSCCS
Class

element:- 200

element:- 10

check stack is empty or not:- True

 P
ractical No.05

Q.5 : write a program to implement queue with insertion ,deletion ,traversal

operations 1.Using list

A) Code:-

q=[] #right to left

q.append(10)
q.append(20)
q.append(30)
print(q)
print("Length of queue

is:-",len(q)) q.pop(0)

q.pop(0)

print(q)

Output:-

[10, 20, 30]

Length of queue is:- 3

[30]

B) Code:-

q=[] #left to right

q.insert(0,10)
q.insert(0,20)
q.insert(0,30)
print(q)
print("Length of queue
is:-",len(q)) q.pop()
q.pop()

print(q)

Output:-

[30, 20, 10]

Length of queue is:- 3

[30]

2. Using Modules

A) Code:-
import collections

q=collections.deque() #left to right

q.appendleft(10)

q.appendleft(20)
q.appendleft(30)
print(q)
print("No of elements in deque is :-",len(q)) #printing length of stack
print("No.of elements in deque is:-",q.count(10)) #To count the
deque q.pop()

q.pop()

print(q)

Output:-

deque([30, 20, 10])

No of elements in deque is :- 3
No.of elements in deque is:- 1
deque([30])
 B) Code:-
import collections
q=collections.deque() #right to left
q.appendleft(10)
q.appendleft(20)
q.appendleft(30)
print(q)
print("No of elements in deque is :-",len(q)) #printing length of stack
print("No.of elements in deque is:-",q.count(10)) #To count the
deque q.popleft()

q.popleft()

print(q)

Output:-

deque([30, 20, 10])

No of elements in deque is :- 3
No.of elements in deque is:- 1
deque([10])
 P
ractical No.06

Q.6 write a program to implement Priority queue with insertion, deletion, traversal operations.
A) Code:-

#Increasing

order q=[]

q.append(150)

q.append(300)

q.append(500)
q.append(130)
print("Original Queue:",q)
q.sort()
print("After Sorting:",q)

#Removing the highest priority

element. print("Removed
Element:",q.pop()) print("Queue after
pop:",q)

Output:-

Original Queue: [150, 300, 500, 130]

After Sorting: [130, 150, 300, 500]

Removed Element: 500

Queue after pop: [130, 150, 300]

B) Code:-
#Decreasing
order q=[]
q.append(150)
q.append(300)
q.append(500)
q.append(130)
print("Original Queue:",q)
q.sort(reverse=True)
print("After Sorting:",q)
#Removing the highest priority
element. print("Removed
Element:",q.pop(0)) print("Queue after
pop:",q)

Output:-

Original Queue: [150, 300, 500,

130] After Sorting: [500, 300, 150,

130] Removed Element: 500

Queue after pop: [300, 150, 130]

C) Code:-
#Decreasing
order q=[]
q.append(150)
q.append(300)
q.append(500)
q.append(130)
print("Original Queue:",q)
q.sort(reverse=True)
print("After Sorting:",q)
#Removing the highest priority

element. print("Removed
Element:",q.pop(0))
print("Queue after pop:",q)
q.append(350)
q.append(380)
q.append(800)
q.append(750)
print("Queue Before
Sorting:",q)
q.sort(reverse=True)
print("After Sorting:",q)

#Removing the highest priority

element. print("Removed
Element:",q.pop(0))

Output:-

Original Queue: [150, 300, 500, 130]

After Sorting: [500, 300, 150, 130]

Removed Element: 500

Queue after pop: [300, 150, 130]

Queue Before Sorting: [300, 150, 130, 350, 380, 800,

750] After Sorting: [800, 750, 380, 350, 300, 150, 130]

Removed Element: 800

2. Using module

A) Code:-

import queue
q=queue.PriorityQueue()
q.put(150)
q.put(460)

q.put(20)
q.put(45)
q.put(10)

q.put(34)

q.put(100)

print("Elements in queue:",)
for n in list(q.queue):
print(n,end=" ")
#Removing elements from queue
print("/nRemoved Element:",q.get())
print("Removed Element:",q.get())
print("Removed Element:",q.get())
print("Removed Element:",q.get())

Output:-

Elements in queue:

10 20 34 460 45 150 100

Removed Element: 10

Removed Element: 20

Removed Element: 34
Removed Element: 45

B) Code:-

# node structure

class Node:

def init (self, data):

self.data = data
self.next = None

#class Linked List

class LinkedList:

def init (self):

self.head = None

#Add new element at the start of the

list def push_front(self, newElement):
newNode = Node(newElement)
newNode.next = self.head

self.head = newNode

#display the content of the

list def PrintList(self):

temp = self.head

if(temp != None):

print("The list contains:", end="

") while (temp != None):

print(temp.data, end=" ")

temp = temp.next

print()
else:
print("The list is empty.")

# test the code

MyList =

LinkedList()
#Add three elements at the start of the list.
MyList.push_front(10

MyList.push_front(20

MyList.push_front(30

) MyList.PrintList()

Output:-

The list contains: 30 20 10

 P
ractical No.07

Q. Write a program to implement Binary Tree with insertion,deletion,traversal operations

Code:-

class Node:

def init (self,key):

self.left=None
self.right=None
self.val=key
#traverse preorder

def

traversePreOrder(self):

print(self.val,end=' ')

if self.left:
self.left.traversePreOrder()
if self.right:
self.right.traversePreOrder(
) #traverse inorder
def
traverseInOrder(self): if
self.left:
self.left.traverseInOrder(
) print(self.val,end=' ')
if self.right:
self.right.traverseInOrder(
) #Traverse PostOrder
def
traversePostOrder(self): if
self.left:
self.left.traversePostOrder(
)
if self.right:

self.right.traversePostOrder()

print(self.val,end=' ')

root=Node(1)

root.left=Node(2)

root.right=Node(3)

root.left.left=Node(4)

root.left.right=Node(5)

print("pre order
Traversal:",end="")
root.traversePreOrder()

print("\nIn order
Traversal:",end="")
root.traverseInOrder()

print("\nPost order
Traversal:",end="")
root.traversePostOrder()

Output:-

pre order Traversal:1 2 4 5 3

In order Traversal:4 2 5 1 3
Post order Traversal:4 5 2 3 1
 P
ractical No.08

Q. Write a program to implement Graph with insertion, deletion, traversal operations.

Code:-

# Graph implementation using

dictionary class Graph:

def init (self, gdict=None):

if gdict is None:

gdict = {}
self.gdict =
gdict
def getVertices(self):

return list(self.gdict.keys())
def getEdges(self):

return
list(self.gdict.values())
graph_element = {
"a": ["b", "c"],

"b": ["a", "d"],

"c": ["a", "d"],

"d": ["b", "c", "e"],

"e": ["d"]
}

g = Graph(graph_element)
print("Representation of graph using
dictionary") print(graph_element)
print("\nKeys:")
print(g.getVertices())
print("\nEdges:")
print(g.getEdges())

Output:-

Representation of graph using dictionary

{'a': ['b', 'c'], 'b': ['a', 'd'], 'c': ['a', 'd'], 'd': ['b', 'c', 'e'], 'e': ['d']}

Keys:

['a', 'b', 'c', 'd', 'e']

Edges:

[['b', 'c'], ['a', 'd'], ['a', 'd'], ['b', 'c', 'e'], ['d']]
 P
ractical No.09

Q. Write a program to implement Huffman coding algorithms.

Code:-

# Huffman Coding in python

string = 'BCAADDDCCACACAC'

# Creating tree nodes

class

NodeTree(object):

def init (self, left=None, right=None):

self.left = left

self.right = right

def children(self):

return (self.left, self.right)

def nodes(self):

return (self.left, self.right)

def str (self):

return '%s_%s' % (self.left, self.right)

# Main function implementing huffman coding
def huffman_code_tree(node, left=True,
binString=''): if type(node) is str:

return {node: binString}

(l, r) = node.children()

d = dict()

d.update(huffman_code_tree(l, True, binString +

'0')) d.update(huffman_code_tree(r, False, binString
+ '1')) return d

# Calculating frequency
freq = {}
for c in string:
if c in freq:

freq[c] += 1

else:

freq[c] = 1

freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)

nodes = freq

while len(nodes) > 1:

(key1, c1) = nodes[-
1]
(key2, c2) = nodes[-

2] nodes = nodes[:-2]

node = NodeTree(key1, key2)

nodes.append((node, c1 + c2))

nodes = sorted(nodes, key=lambda x: x[1], reverse=True)

huffmanCode = huffman_code_tree(nodes[0][0])

print(' Char | Huffman code ')

print(' ')

for (char, frequency) in freq:

print(' %-4r |%12s' % (char, huffmanCode[char]))

Output:-

Char | Huffman code

'C' | 0

'A' | 11
'D' | 101

'B' | 100
 P
ractical No.10

Q.10 Write a program to create basic Hash Table for insertion, deletion, traversal
operations (assume that there are no collisions)

Code:-

class HashTable1:
def init (self, size):

self.size = size

self.table = [None] * size

def _hash_function(self, key):

return hash(key) % self.size

def insert(self, key, value):

index =

self._hash_function(key)

self.table[index] = (key, value)

def delete(self, key):

index = self._hash_function(key)
if self.table[index] and self.table[index][0] ==

key: self.table[index] = None

def get(self, key):

index = self._hash_function(key)
if self.table[index] and self.table[index][0] ==

key: return self.table[index][1]

else:
return None

def traverse(self):

for item in self.table:

if item:

print(f"Key: {item[0]}, Value: {item[1]}")

# Example usage:

ht = HashTable1(10)

ht.insert("apple", 5)

ht.insert("banana", 10)
ht.insert("cherry", 15)

print("HashTable:"

) ht.traverse()

ht.delete("banana") print("\
nAfter deleting 'banana':")
ht.traverse()

search_result =

ht.get("cherry") if

search_result is not None:

print("\nSearch result for 'cherry':",

search_result) else:

print("\n'cherry' not found in the HashTable.")

 Output:-

HashTable:

Key: cherry, Value: 15

Key: apple, Value: 5

Key: banana, Value:

10

After deleting 'banana':

Key: cherry, Value: 15
Key: apple, Value: 5

Search result for 'cherry': 15