1) Write a python program to use and demonstrate basic data
structures.
lst=["Python","Java","HTML","CSS","Bootstrap","php"]
print(lst)
print(lst[0]) #Accessing a values of a list using an index number
print(lst[1:5])
lst[2]="Advance Java"
print(lst) #Updating a list using index number
del lst[2]
print(lst) #Deleting a list element using an index number
tup=("Python","Java","HTML","CSS","Bootstrap","php")
print(tup)
print(tup[0]) #Accessing a values of a tuple using an index number
print(tup[1:5])
tup1=("Advance Java","DS Python")
print(tup+tup1) #Updating a tuple by creating a new tuple
# del tup,tup1 # Deletion of a tuple using a del keyword
# print(tup1+tup)
lang={"Python","Java","HTML","CSS","Bootstrap","php"}
print(lang)
for x in lang: #Accessing a vlues of a set
print(x)
[Link]("Advance Java") #Adding items to a set
print(lang)
[Link]("Advance Java")
print(lang) #Removing an element using discard method
lang1={"Advance Java","DS with python","HTML","php"}
print(lang|lang1) #Union of set
dict1={
"Name":"Python",
"year":1989,
"founder":"Guido van Rossum"
}
print(dict1)
print(dict1)
print(dict1["Name"]) #Accessing a values of dictionary using a key
pairs
print(dict1["year"])
dict1["type"]="object oriented programing language"
print(dict1["type"]) #Updating a dictionary by adding a new entry
del dict1["type"]
del dict1; #Deleting a whole dictionary using a del keyword
# print(dict1)
2) Give an example to show the implementation of an ADT with all it
operation
lst=["Python","Java","HTML","CSS","Bootstrap","php"]
print(lst)
print(lst[2])
[Link](3,"Advance Java")
print(lst)
[Link]("Advance Java")
print(lst)
print(len(lst))
del lst
print(lst)
''' Implementation of stack on list'''
lst_mystack=[]
lst_mystack.append("Python")
lst_mystack.append("Java")
lst_mystack.append("HTML")
lst_mystack.append("CSS")
print(lst_mystack)
lst_mystack.pop()
lst_mystack.pop()
lst_mystack.pop()
lst_mystack.pop()
print(lst_mystack)
# Implmentation of queue using queue module
from queue import Queue
from resource import prlimit
q=Queue(maxsize=4)
print("Initial Size Before Insertion:",[Link]())
[Link](1)
[Link](2)
[Link](3)
[Link](4)
print("After Insertion:",[Link]())
print("Queue is Full or Not:",[Link]())
print("Size of Queue:",[Link]())
print("Removing Elements:")
print([Link]())
print([Link]())
print([Link]())
print("Empty or Not??",[Link]())
print([Link]())
print("Empty or Not??",[Link]())
print("Size of Queue:",[Link]())
3) Implement Linear Search compute space and time complexities,
plot graph using asymptomatic notations.
import time
import numpy as np
from matplotlib import pyplot as plt
def linear_search(A,x):
for i in range(0, len(A)):
if A[i] == x:
print("search is success at possition",i)
return
print("Search is not success")
elements = [Link]([i*1000 for i in range(1,40)])
[Link]('List Length')
[Link]('Time Complexity')
times = list()
for i in range(1, 40):
start = [Link]()
a = [Link](1000, size=i*1000)
linear_search(a,1)
end=[Link]()
[Link](end - start)
print("time taken for linear search in ", i*1000,"Elements is", end -
start,"s")
[Link](elements, times, label = "Linear Search")
[Link]()
[Link]()
[Link]()
4) Write a linear search algorithm and give an example for that
algorithm.
# Algorithm:
LinearSearch(array, key)
for each item in the array
if item == value
return its index
# Program:
def linearSearch(array, n, x):
for i in range(0, n):
if (array[i] == x):
return i
return -1
array = [2, 4, 0, 1, 9]
x = 1
n = len(array)
result = linearSearch(array, n, x)
if(result == -1):
print("Element not found")
else:
print("Element found at index: ", result)
5) Implement Bubble,Selection,insertion sorting algorithms compute
space and time complexities, plot graph using asymptomatic
notations.
import time
import numpy as np
from matplotlib import pyplot as plt
# Selection Sort
def selectionSort(array):
i = 0
while i<len(array):
j = i
k = i+1
while k<len(array):
if array[k]<array[j]:
j=k
k=k+1
array[i],array[j]=array[j],array[i]
i=i+1
# Insertion Sort
def insertionSort(arr):
for i in range(1,len(arr)):
key = arr[i]
j = i-1
while j>=0 and key<arr[j]:
arr[j+1]=arr[j]
j -=1
arr[j+1]=key
# Bubble Sort
def BubbleSort(array):
n=len(array)-1
while n>=1:
i=0
while i<n:
if array[i]>array[i+1]:
array[i],array[i+1]=array[i+1],array[i]
i = i+1
n=n-1
# Main
sorts=[
{
"name":"Selection Sort",
"sort": lambda arr:selectionSort(arr)
},
{
"name":"Insertion Sort",
"sort":lambda arr:insertionSort(arr)
},
{
"name":"bubble sort",
"sort":lambda arr:BubbleSort(arr)
},
]
elements = [Link]([i*1000 for i in range(1,5)])
[Link]('List Length')
[Link]('Time Complexity')
for sort in sorts:
times = list()
start_all = [Link]()
for i in range(1,5):
start = [Link]()
a=[Link](1000, size = i*1000)
sort["sort"](a)
end = [Link]()
[Link](end - start)
print(sort["name"], "Sorted", i * 1000, "Elements in", end - start, "s")
end_all=[Link]()
print(sort['name'],"Sorted Elements in",end_all - start_all, "s")
[Link](elements, times, label = sort["name"])
[Link]()
[Link]()
[Link]()
6) Sort the array using any three sorting techniques.
[22,-11,33,88,77,66,-64,44,56]
def bubbleSort(array):
for i in range(len(array)):
swapped = False
for j in range(0, len(array) - i - 1):
if array[j] > array[j + 1]:
temp = array[j]
array[j] = array[j+1]
array[j+1] = temp
swapped = True
if not swapped:
break
data = [22,-11,33,88,77,66,-64,44,56]
print('Unsorted Array:\n', data)
bubbleSort(data)
print('Sorted Array in Ascending Order:')
print(data)
def insertionSort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i-1
while j >=0 and key < arr[j] :
arr[j+1] = arr[j]
j -= 1
arr[j+1] = key
arr = [22,-11,33,88,77,66,-64,44,56]
print('Unsorted Array:\n', arr)
insertionSort(arr)
print ("Sorted Array in Ascending Order:")
print(data)
for i in range(len(arr)):
print ("%d" %arr[i])
def selectionSort(array, size):
for step in range(size):
min_idx = step
for i in range(step + 1, size):
if array[i] < array[min_idx]:
min_idx = i
(array[step], array[min_idx]) = (array[min_idx], array[step])
data = [22,-11,33,88,77,66,-64,44,56]
print("Unsorted Array is: \n",data)
size = len(data)
selectionSort(data, size)
print('Sorted Array in Ascending Order:')
print(data)
7) Write a python program to implement binary search tree and its
Operations
class Node:
def __init__(self, key):
[Link] = None
[Link] = None
[Link] = key
def insert(root, key):
if root is None:
return Node(key)
else:
if [Link] == key:
return root
elif [Link] < key:
[Link] = insert([Link], key)
else:
[Link] = insert([Link], key)
return root
def inorder(root):
if root:
inorder([Link])
print([Link])
inorder([Link])
r = Node(50)
r = insert(r, 30)
r = insert(r, 20)
r = insert(r, 40)
r = insert(r, 70)
r = insert(r, 60)
r = insert(r, 80)
inorder(r)
8) Generate the 10 sequence of Fibonacci series using recursive
method.
# Python program to display the Fibonacci sequence
def recur_fibo(n):
if n <= 1:
return n
else:
return(recur_fibo(n-1) + recur_fibo(n-2))
nterms = 10
if nterms <= 0:
print("Plese enter a positive integer")
else:
print("Fibonacci sequence:")
for i in range(nterms):
print(recur_fibo(i))
9) Write a python code to insert a data at the beginning of the linked
list.
class Node:
def __init__(self, dataval=None):
[Link] = dataval
[Link] = None
class SLinkedList:
def __init__(self):
[Link] = None
# Print the linked list
def listprint(self):
printval = [Link]
while printval is not None:
print ([Link])
printval = [Link]
def AtBegining(self,newdata):
NewNode = Node(newdata)
[Link] = [Link]
[Link] = NewNode
list = SLinkedList()
[Link] = Node("Mon")
e2 = Node("Tue")
e3 = Node("Wed")
[Link] = e2
[Link] = e3
[Link]("Sun")
[Link]()
10) Write a python program to implement stack data structure.
class Stack:
def __init__(self):
[Link] = []
def add(self, dataval):
if dataval not in [Link]:
[Link](dataval)
return True
else:
return False
def peek(self):
return [Link][-1]
AStack = Stack()
[Link]("Mon")
[Link]("Tue")
[Link]()
print([Link]())
[Link]("Wed")
[Link]("Thu")
print([Link]())
11) Write a python program to perform the operations on stack.
def create_stack():
stack = []
return stack
def check_empty(stack):
return len(stack) == 0
def push(stack, item):
[Link](item)
print("pushed item: " + item)
def pop(stack):
if (check_empty(stack)):
return "stack is empty"
return [Link]()
stack = create_stack()
push(stack, str(1))
push(stack, str(2))
push(stack, str(3))
push(stack, str(4))
print("popped item: " + pop(stack))
print("stack after popping an element: " + str(stack))
12) Give an example to show the implementation of queue using list.
queue = []
# Adding elements to the queue
[Link]('Python')
[Link]('Java')
[Link]('HTML')
print("Initial queue")
print(queue)
# Removing elements from the queue
print("\nElements dequeued from queue")
print([Link](0))
print([Link](0))
print([Link](0))
print("\nQueue after removing elements")
print(queue)
13) Write a python program to demonstrate hash functions.
result = hash(21) # integer value
result2 = hash(22.2) # decimal value
print(result)
print(result2)
result = hash("javatpoint") # string value
result2 = hash((1,2,22)) # tuple value
print(result)
print(result2)
result = hash("javatpoint") # string value
result2 = hash([1,2,22]) # list
print(result)
print(result2)
class Student:
def __init__(self,name,email):
[Link] = name
[Link] = email
student = Student("Arun", "arun@[Link]")
result = hash(student) # object
print(result)
