Question

use python

In class, we've studied Singly-Linked Lists which are made of nodes that point at subsequent nodes. One of the biggest annoyances with Linked Lists is the difficulty of going backwards through a list (such as getting the previous node or traversing the list backwards). An intuitive solution to this inefficiency is the doubly-linked list, which adds pointers to previ- ous nodes. Doubly-Linked Lists are not very different from Singly-Linked Lists, but are far more common because they are easier to use. In this problem, you are to implement a Doubly-Linked List from scratch (you may use the Singly- Linked List code from class). You will have to create 2 classes (Node and Doubly_linked_list). The Node class will have the following methods: init(value, prev, next) • get_prev() • get_next • get_value() • set_prev(node) • set_next(node) • set_value(val) The Doubly_linked_list class must have the following methods: _init_0 • add_to_end(val): adds element as last • add_to_front(val): adds element to first • delete(val): deletes first occurrence of val • reverse(): reverses the list • compare(lst): check if list has the same values in the same order as the DLL • find(val): return the index(as it would be in a list) of the first occurrence of val

Answer 1

#####################################################################################################

class Node():

def __init__(self,data, next = None, prev = None):   
               #constructure
self.data = data #data the mid turm
self.nextNode = next #next pointer
self.prevNode = prev #previous pointer

def get_prev(self): #method for getting previous node
if self.prevNode != None: #if previioue node is present
return self.prevNode #return the node

def get_next(self): #getting next node
if self.nextNode != None: #if next node is present
return self.nextNode #return the next bode
  
def get_value(self): #getting value of current node
if self != None: #is current node is present
return self.data #returnthe value of urrent node
  
def set_prev(self,prev): #method to set previous node
self.prevNode = prev #set
  
def set_next(self,next): #method for settinf next node
self.nextNode = next

def set_value(self,value): #seting value
self.data = value

class DoublyLinkedList(): #class linked list

def __init__(self): #all the constructure
self.head = None #head tail and count initialize
self.count = 0 #count
self.tail = None #tail

def add_to_front(self,data): #data added to front of the doubly linked list
self.count+=1 #count incremented
newNode = Node(data) #new node witth data as value
if not self.head: # if it is first node
self.head = newNode #head tail initialize by same
self.tail = newNode
else: #else new node added front and head moved
newNode.nextNode = self.head
self.head.prevNode = newNode
self.head = newNode

def add_to_last(self,data): #add to last
self.count+=1
newNode = Node(data) #new node created
  
if self.head == None:
add_to_front(data)
return
else:
self.tail.nextNode = newNode #node added to tail
newNode.prevNode = self.tail #and tail moved next
self.tail = newNode

def delete(self, data): #method to delete node
  
currentNode = self.head
while(currentNode!=self.tail and currentNode.data != data):
#iterate to the desired node
currentNode = currentNode.nextNode
if currentNode == self.tail and currentNode.data != data:
#if last node is still not equall
print("Not found") #the not found prinetd
else:
prevNode = currentNode.prevNode #else deleted and next node preve node balances
nextNode = currentNode.nextNode
prevNode.nextNode = nextNode
nextNode.prevNode = prevNode
self.count-=1   
  
def reverse(self): #reversing the linked list
temp = None
current = self.head
self.tail = self.head

while current.nextNode!=None:#iterate over the linked list
temp = current.prevNode
current.prevNode = current.nextNode
current.nextNode = temp
current = current.prevNode #jsut swapping the nextNode with prevNode

temp = current.prevNode
current.prevNode = current.nextNode #last node also swapped
current.nextNode = temp
  
if temp.nextNode is not None:
self.head = temp.prevNode #head assign to the last node
  
def printall(self): #function for printing Not asked but used to print each step
currentNode = self.head
while currentNode.nextNode:
print(currentNode.data,end = " ")
currentNode = currentNode.nextNode
print(currentNode.data)

def compare(self,lis): #compare with the list
if len(lis) == self.count: #if size of list and linked list equall

flag = True #flag for equality
if(lis[0] == self.head.data and lis[-1] == self.tail.data):
#if first and last element is same
current = self.head
indx = 0

while current.nextNode: #iterate over linked list

if current.data != lis[indx]: #if any data not matched
flag = False
return False #return false
current = current.nextNode
indx+=1
  
  
else: #if first and last element not match
flag = False
return False
else:#if size not matched
flag = False
return False

return flag #if they are equall
  
def find(self,data): #find data
indx = 0;
current =self.head
while current.nextNode!=None: #iterate over the list
if current.data == data: #if data found
  
return indx #return index
current = current.nextNode #next node

indx+=1
  
  
  

l = DoublyLinkedList() #linked list created
for i in range(7,15):
l.add_to_front(i) #insert 10-1 reverse order front
print("_________________________________________________________________")   
l.printall() #print the linked list
print("_________________________________________________________________")
for i in range(20,25): #enter 110-115

l.add_to_last(i) #added to last

l.printall() #print the list
print("_________________________________________________________________")

print(l.find(15)) #find 10

print("_________________________________________________________________")

l.delete(11) #delete 114
l.printall() #printall

print("_________________________________________________________________")
l.reverse() #reverse

l.printall() #print all
print("_________________________________________________________________")
list1 = [1,2,3,4,5,6,7,8,9]
print(list1)
l.printall()
print(l.compare(list1)) #compare to list for true
print("_________________________________________________________________")
list2 = [24,23,22,21,20,7,8,9,10,12,13,14]
print(list2)
l.printall()
print(l.compare(list2)) #compare for false
print("_________________________________________________________________")

  
  ##################################################################################################

Code Snippet:

class Node(): def _init__(self, data, next = None, prev = None): #constructure self.data = data #data the mid turm self.nextNode = next #next pointer self.prevNode = prev #previous pointer def get_prev(self): #method for getting previous node if self.prevNode != None: #if previioue node is present return self.prevNode #return the nodel def get_next(self): #getting next node if self.nextNode != None: #if next node is present return self.nextNode #return the next bode def get_value(self): if self != None: return self.data #getting value of current node #is current node is present #returnthe value of urrent node #method to set previous node #set def set_prev(self, prev): self.prevNode = prev def set_next(self, next): self.nextNode = next #method for settinf next node def set_value(self, value): self.data = value #seting value #class linked list class DoublyLinkedList(): def init__(self): self.head = None self.count = 0 self.tail None #all the constructure #head tail and count initialize #count #tail def add_to_front (self, data): #data added to front of the doubly linked lis

def add to front (self, data): #data added to front of the doubly linked list self.count+=1 #count incremented newNode = Node (data) #new node witth data as value if not self.head: # if it is first node self.head = newNode #head tail initialize by same self.tail = newNode else: #else new node added front and head moved newNode.nextNode = self. head self.head.prevNode = newNode self.head = newNode def add to last (self, data): #add to last self.count+=1 newNode = Node (data) #new node created if self. head == None: add to front (data) return else: self.tail.nextNode = newNode #node added to tail newNode.prevNode = self.tail #and tail moved next self.tail = newNode def delete(self, data): #method to delete node currentNode = self.head while(currentNode!=self.tail and currentNode. data != data): #iterate to the desired node currentNode = currentNode. nextNode if currentNode == self.tail and currentNode.data != data: #if last node still not equall print("Not found) #the not found prinetd else: prevNode = currentNode.prevNode #else deleted and next node preve node balances nextNode = currentNode. nextNode prevNode. nextNode = nextNode nextNode.prevNode = prevNode self.count -=1 def reverse(self): #reversing the linked list temp = None current = self. head self. tail = self.head while current.nextNode!=None:#iterate over the linked list temp = current.prevNode current.prevNode = current.nextNode current.nextNode = temp current = current.prevNode #jsut swapping the nextNode with prevNode temp = current.prevNode current.prevNode = current.nextNode #last node also swapped

if temp.nextNode is not None: self.head temp.prevNode #head assign to the last node def printall(self): #function for printing Not asked but used to print each step currentNode = self.head while currentNode. nextNode: print(currentNode.data, end = "") currentNode = currentNode.nextNode print(currentNode.data) def compare(self,lis): #compare with the list if len(lis) self.count: #if size of list and linked list equall flag = True #flag for equality if(lis[0] == self.head.data and lis[-1] == self.tail.data): #if first and last element is same current = self.head indx = 0 == while current.nextNode: #iterate over linked list if current.data != lis[indx]: #if any data not matched flag = False return false #return false current = current.nextNode indx+=1 else: #if first and last element not match flag = False return false else:#if size not matched flag = False return false return flag #if they are equall def find(self, data): #find data indx = 0; current =self.head while current.nextNode!=None: #iterate over the list if current. data == data: #if data found return indx #return index current = current.nextNode #next node indx+=1

#linked list created 1 = DoublyLinkedList() for i in range (7,15) :| l.add to front(i) #insert 10-1 reverse order front print(". l.printall() #print the linked list print(" for i in range (20,25): #enter 110-115 #added to last 1.add_to_last(i) l.printall() print(" #print the list ") print(l.find(15)) #find 10 print(". ") 1.delete(11) l.printall() #delete 114 #printall ") print(" 1.reverse() #reverse ") l.printall) #print all print(". listi = [1,2,3,4,5,6,7,8,9] print(listi) l.printall() print(l.compare(list1)) #compare to list for true print(" list2 = [24,23,22,21,20,7,8,9,10,12,13,14] print(list2) l.printall() print(l.compare(list2)) #compare for false print(". ")

OUTPUT:

14 13 12 11 10 9 8 7 14 13 12 11 10 9 8 7 20 21 22 23 24 None 14 13 12 10 9 8 7 20 21 22 23 24 24 23 22 21 20 7 8 9 10 12 13 14 [1, 2, 3, 4, 5, 6, 7, 8, 9] 24 23 22 21 20 7 8 9 10 12 13 14 False [24, 23, 22, 21, 20, 7, 8, 9, 10, 12, 13, 14] 24 23 22 21 20 7 8 9 10 12 13 14 True