[Solved]-Python Basic Data Structures Implement Three Abstract Data Types Using Unorderedlist Class Q37287979

Python Basic Data Structures

implement three abstract data types using the UnorderedListclass.

We already have the regular list in hw.py.

How do we use the UnorderedList object instead of the regularPython list in the hw.py?

Thanks!

hw.py

——————-

from UnorderedList import *

# Problem 1

class QueueFE:
def __init__(self):
self.items = []

def isEmpty(self):
return self.items == []

def enqueue(self, item):
self.items.insert(0,item)

def dequeue(self):
return self.items.pop()

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

# Problem 2

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

def isEmpty(self):
return self.items == []

def push(self, item):
self.items.append(item)

def pop(self):
return self.items.pop()

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

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

# Problem 3

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

def isEmpty(self):
return self.items == []

def enqueue(self, item):
self.items.insert(0,item)

def dequeue(self):
return self.items.pop()

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

# Problem 4

class Deque:
def __init__(self):
self.items = []

def isEmpty(self):
return self.items == []

def addFront(self, item):
self.items.append(item)

def addRear(self, item):
self.items.insert(0,item)

def removeFront(self):
return self.items.pop()

def removeRear(self):
return self.items.pop(0)

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

————————–

UnorderedList

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

def getData(self):
return self.data

def getNext(self):
return self.next

def setData(self,newdata):
self.data = newdata

def setNext(self,newnext):
self.next = newnext

# API defined here:http://interactivepython.org/courselib/static/pythonds/BasicDS/TheUnorderedListAbstractDataType.html
class UnorderedList:

def __init__(self):
self.head = None

def isEmpty(self):
return self.head == None

def add(self,item):
temp = Node(item)
temp.setNext(self.head)
self.head = temp

def size(self):
current = self.head
count = 0
while current != None:
count = count + 1
current = current.getNext()

return count

def search(self,item):
current = self.head
found = False
while current != None and not found:
if current.getData() == item:
found = True
else:
current = current.getNext()

return found

def remove(self,item):
current = self.head
previous = None
found = False
while not found:
if current.getData() == item:
found = True
else:
previous = current
current = current.getNext()

if previous == None:
self.head = current.getNext()
else:
previous.setNext(current.getNext())

def index(self, item):
current = self.head

idx = 0
while current != None:
if current.getData() == item:
return idx
else:
current = current.getNext()
idx += 1

raise ValueError(“%r is not in unordered list” % item)

def insert(self, pos, item):
node = Node(item)

if pos == 0:
node.setNext(self.head)
self.head = node
else:
index = 0
previous, current = None, self.head

while index < pos:
index += 1
previous, current = current, current.getNext()
if current is None and index < pos:
raise IndexError(“unordered list assignment index out ofrange”)

node.setNext(current)
previous.setNext(node)

def pop(self, pos):
if self.head is None:
raise IndexError(“pop from empty unordered list”)

if pos == 0:
item = self.head.getData()
self.head = self.head.getNext()
return item

previous, current = None, self.head
index = 0

while index < pos:
previous, current = current, current.getNext()
index += 1

previous.setNext(current.getNext())
return current.getData()

def append(self, item):
if self.head is None:
self.head = Node(item)
return

current, next = self.head, self.head.getNext()

while next is not None:
current, next = next, next.getNext()

current.setNext(Node(item))

Expert Answer

---

Answer to Python Basic Data Structures implement three abstract data types using the UnorderedList class. We already have the regu… . . .