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

Answer :

Python code for above problem

class Node:
def __init__(self,value,prev,next):
self.value=value
self.prev=prev
self.next=next
  
def get_prev(self):
return self.prev
  
def get_next(self):
return self.next
  
def get_value(self):
return self.value
  
def set_prev(self,node):
self.prev=node
  
def det_next(self,node):
self.next=node
  
def set_value(self,val):
self.value=val
  
class DoubleLinkedList:
def __init__(self):
self.head=None
self.tail=None
self.size=0
  
def add_to_front(self,val):
node=Node(val,None,None)
if self.head is None:
self.head=node
self.tail=node
else:
self.head.prev=node
node.next=self.head
self.head=node
self.size+=1
  
def add_to_end(self,val):
node=Node(val,None,None)
if self.head is None:
self.head=node
self.tail=node
else:
self.tail.next=node
node.prev=self.tail
self.tail=node
self.size+=1
  
def delete(self,val):
node=self.head
prev=None
while node is not None and node.value!=val:
prev=node
node=node.next
  
if node is None:
return
  
if prev is None:
self.head=self.head.next
if self.head is None:
self.tail=None
else:
self.head.prev=None
else:
prev.next=node.next
node.prev.next=prev
self.size-=1
  
def find(self,val):
node=self.head
index=0
while node is not None:
if node.value==val:
return index
index+=1
node=node.next
return -1
  
def reverse(self):
if self.size==0 or self.size==1:
return
n1=self.head
n2=self.tail
for i in range(self.size//2):
temp=n1.value
n1.value=n2.value
n2.value=temp
n1=n1.next
n2=n2.prev
  
def compare(self,lst):
if(self.size!=len(lst)):
return False
node=self.head
index=0
while node is not None:
if node.value!=lst[index]:
return False
index+=1
node=node.next
return True
  
def print_list(self):
node=self.head
while node is not None:
print(node.value,end=" ")
node=node.next
print("")
  
# testing main method  
def main():
dll=DoubleLinkedList()
for i in range(0,5,2):
dll.add_to_front(i)
dll.add_to_end(i+1)
dll.print_list() # prints [4,2,0,1,3,5]
dll.reverse()
dll.print_list() # prints [5 3 1 0 2 4]
print(dll.compare([5,3,1,0,2,4])) # prints True
print(dll.compare([5,3,1,2,4])) # prints False
dll.delete(5)   
dll.print_list() # prints [3 1 0 2 4]
dll.delete(8)
dll.print_list() # prints [3 1 0 2 4]
print(dll.find(5)) # prints -1
print(dll.find(3)) # prints 0
  

main()

Mention in comments if any mistakes or errors are found. please give me up vote. Thank you.