Question

Python coding conceptual questions -

Conceptual Questions Suppose you are given a (strange) computer that can only perform the following instructions (in addition to if and while): S-create_stack() create stack makes a new stack s iS.pop() removes the top item from stack s and places it in variable i .S.push (i) makes item i the top item in stack s Solve the following problems and justify your answers: 1. (10 pts) Show how you can use these operations to implement a queue (operations Q = create-queue() , enqueue (1) , i -deque . A picture might help to explain your answer .Hint: take a look at the following image push pop pushpop F R Stack 1 Stack 2 Stack 1 Stack 2 Enqueue Dequeue (image from http://www.algoqueue.com/algoqueue/members/get uploaded image load/149) 2. (5 pts) What's the worst case running time of your dequeue implementation? 3. (5 pts) Over a series of n enqueues followed by n dequeues, how many pop() operations does your implementation perform?

Answer 1

Following is the queue implementation using stacks, and in python, we can use lists as the stack using the append and pop operation for push and pop respectively.

Following is the code for the same in python.

# Python3 program to implement Queue using
# Two Stack implementation for making a queue
# Here we can use list as the stack in python
# using the append function as the push operation
# using the pop operation from poping out from the last
class Queue:
    def __init__(self):
        self.s1 = []
        self.s2 = []

    def enQueue(self, x):
        # if first stack is empty
        # Add to top of self.s1
        self.s1.append(x)

    # Dequeue an item from the queue
    def deQueue(self):
        if len(self.s1) == 0:
            print('Q is Empty')
        while len(self.s1) != 0:
            self.s2.append(self.s1[-1])
            self.s1.pop()

        # Push item into self.s1
        x = self.s2[-1]
        self.s2.pop()

        # Push everything back to s1
        while len(self.s2) != 0:
            self.s1.append(self.s2[-1])
            self.s2.pop()
        return x

# Driver code
if __name__ == '__main__':
    q = Queue()
    q.enQueue(55)
    q.enQueue(44)
    q.enQueue(33)

    print(q.deQueue())
    print(q.deQueue())
    print(q.deQueue())

2. Worst case for the dequeue operation in this implementation can be O(n)
As we need to remove all the elements from the one stack and then push them back again to other stack, which could take n operation hence the complexity would be O(n).

3. dequeue for k items would be 2*k

Thus for n enqueue and n dequeue operation.

Enqueue operation: does not require any pop operation.

Dequeue operation: at any time with k entries, we require 2*k pop for one dequeue.

So for n operation: 2*n + 2*(n-1) + 2*(n-2) + 2 *(n-3) + . . . . . + 2*(1)
= 2 *(n + n-1 + n-2 + n-3 + . . . . 1)
= 2* (n * (n-1)) /2
= n*(n-1)

Thanks,