Question

using python file and screenshot the file that show up is correct

Your input data for each application is:

           

7   1   8   9   4   2   5   10   6   3

Treat this data as integer data type.

Push onto and pop off of each of the input items onto a stack implemented in Python.   Identify the item 4 when it is popped off of your stack.

2. Feed this same input data into a Queue implemented in Python.   Identify the item 4 when it is removed from the front of your queue.

3. Feed this same input data into a doubly linked list in its unsorted order. Traverse this list, find the element 4 and remove it from the list. Then remove the last element on this list.

Answer 1

Hi,

->For the first question "Stack implementation " code is given below.

Answer code

class Stack:

    # Constructor
    def __init__(self):
        self.stack = list()
        self.maxSize = 10
        self.top = 0

    # Adds element to the Stack
    def push(self, data):
        if self.top >= self.maxSize:
            return ("Stack Full!")
        self.stack.append(data)
        self.top += 1
        return True

    # Removes element from the stack
    def pop(self):
        if self.top <= 0:
            return ("Stack Empty!")
        item = self.stack.pop()
        self.top -= 1
        return item

    # Size of the stack
    def size(self):
        return self.top


s = Stack()
(s.push(7))
(s.push(8))
(s.push(9))
(s.push(4))
(s.push(2))
(s.push(5))
(s.push(6))
(s.push(3))
while s.size() >0 :
    temp=s.pop()
    if temp ==4:
        print("Value 4 is detected ")
    else:
        print ("pop operation executed \n")

For the second question "queue implementation " code is given below.

Answer code

class Queue:


    def __init__(self):
        self.queue = list()
        self.maxSize = 10
        self.head = 0
        self.tail = 0

    # Adding elements
    def enqueue(self, data):
        # Checking if the queue is full
        if self.size() >= self.maxSize:
            return ("Queue Full")
        self.queue.append(data)
        self.tail += 1
        return True

        # Deleting elements

    def dequeue(self):
        # Checking if the queue is empty
        if self.size() <= 0:
            self.resetQueue()
            return ("Queue Empty")
        data = self.queue[self.head]
        self.head += 1
        return data

    # Calculate size
    def size(self):
        return self.tail - self.head

    # Reset queue
    def resetQueue(self):
        self.tail = 0
        self.head = 0
        self.queue = list()


q = Queue()
#Values are entered in the format given =7   1   8   9   4   2   5   10   6   3


(q.enqueue(7))
(q.enqueue(1))
(q.enqueue(8))
(q.enqueue(9))
(q.enqueue(4))
(q.enqueue(2))
(q.enqueue(5))
(q.enqueue(10))
(q.enqueue(6))
(q.enqueue(3))
while q.size() > 0:
    temp=q.dequeue()
    if temp == 4:
        print("Value 4 is detected and dequeued \n")
    else:
        print("Dequeue operation is done \n")

For the second question "Double link list " code is given below.

Answer code

class Node:

    def __init__(self, data, nextNode=None):
        self.data = data
        self.nextNode = nextNode

    def getData(self):
        return self.data

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

    def getNextNode(self):
        return self.nextNode

    def setNextNode(self, val):
        self.nextNode = val




class LinkedList:

    def __init__(self, head=None):
        self.head = head
        self.size = 0

    def getSize(self):
        return self.size

    def addNode(self, data):
        newNode = Node(data, self.head)
        self.head = newNode
        self.size += 1
        return True

    def printNode(self):
        curr = self.head
        while curr:
            print(curr.data)
            curr = curr.getNextNode()

    def removeNode(self, value):

        prev = None
        curr = self.head
        while curr:
            if curr.getData() == value:
                if prev:
                    prev.setNextNode(curr.getNextNode())
                else:
                    self.head = curr.getNextNode()
                return True

            prev = curr
            curr = curr.getNextNode()

        return False






myList = LinkedList()
print("Inserting 7   1   8   9   4   2   5   10   6   3 \n")
(myList.addNode(7))
(myList.addNode(1))
(myList.addNode(8))
(myList.addNode(9))
(myList.addNode(4))
(myList.addNode(2))
(myList.addNode(5))
(myList.addNode(10))
(myList.addNode(6))
(myList.addNode(3))
temp=(myList.removeNode(4))
if temp==True:
    print("Value 4 is removed successfully ")

Hope i was able to help you