Data Structures in Python

Assertion (A): The major implementation of using a data structure is to manage the storage of data in the memory efficiently.

Reasoning (R): Data structure refers to the way memory is allocated for holding data using minimum space. It leads to faster data access during the execution of the program.

1. Both A and R are true and R is the correct explanation of A.
2. Both A and R are true but R is not the correct explanation of A.
3. A is true but R is false.
4. A is false but R is true.

Assertion (A): While working with Stacks, the program should check for Overflow condition before executing push operation and, similarly, check for Underflow before executing pop operation.

Reasoning (R): In Stack, Underflow means there is no element available to remove and Overflow means no further element can be added to it.

1. Both A and R are true and R is the correct explanation of A.
2. Both A and R are true but R is not the correct explanation of A.
3. A is true but R is false.
4. A is false but R is true.

Assertion (A): Stack is a memory structure that works on the principle of FIFO (First In, First Out).

Reasoning (R): Stack is implemented using list and allows to add an element using append() method.

1. Both A and R are true and R is the correct explanation of A.
2. Both A and R are true but R is not the correct explanation of A.
3. A is true but R is false.
4. A is false but R is true.

Assertion (A): A Stack is a linear data structure that stores the elements in First In, First Out order.

Reasoning (R): In Stack, a new element is added and removed from one end only.

1. Both A and R are true and R is the correct explanation of A.
2. Both A and R are true but R is not the correct explanation of A.
3. A is true but R is false.
4. A is false but R is true.

Assertion (A): Stack and Queue are linear data structures.

Reasoning (R): List, tuples and dictionaries are Python built-in linear data structures.

1. Both A and R are true and R is the correct explanation of A.
2. Both A and R are true but R is not the correct explanation of A.
3. A is true but R is false.
4. A is false but R is true.

Assertion (A): An element in a Stack is removed from its Top.

Reasoning (R): The process of removing an element from a Stack is called pop.

1. Both A and R are true and R is the correct explanation of A.
2. Both A and R are true but R is not the correct explanation of A.
3. A is true but R is false.
4. A is false but R is true.

Assertion (A): An error gets displayed when you try to delete an element from an empty Stack.

Reasoning (R): Inserting an element when the Stack is full is termed as Underflow.

1. Both A and R are true and R is the correct explanation of A.
2. Both A and R are true but R is not the correct explanation of A.
3. A is true but R is false.
4. A is false but R is true.

Data Structure means organization of data.

A data structure has well defined operations, behaviour and properties.

A stack is a linear list, also known as LIFO list.

A list is a mutable sequence of data elements indexed by their position.

Traversing means accessing or visiting or processing each element of any data structure.

push is the term coined for insertion of elements in a Stack list.

Consider the following operations done on Stack:

push(5)
push(8)
pop()
push(2)
push(5)
pop()
pop()
pop()
push(1)
pop()

The output of the above snippet is [], empty list.

In the Stack, if a user tries to remove an element from the empty Stack, it is called underflow of stack.

If the elements "A", "B", "C" and "D" are placed in a queue and are deleted one at a time, the order in which they will be removed will be A, B, C and D.

The process of inserting an element in a queue is called enqueue while deleting an element from a queue is called dequeue.

The process of inserting an element in Stack is called:

1. Create
2. Push
3. Evaluation
4. Pop

The process of removing an element from Stack is called:

1. Create
2. Push
3. Evaluation
4. Pop

In a Stack, if a user tries to remove an element from an empty Stack, the situation is called:

1. Underflow
2. Empty collection
3. Overflow
4. Garbage collection

Pushing an element into a Stack already having five elements and a Stack of size 5, then the Stack becomes:

1. User flow
2. Crash
3. Underflow
4. Overflow

Entries in a Stack are "ordered". What is the meaning of this statement?

1. A collection of Stacks can be sorted.
2. Stack entries may be compared with the '<' operation.
3. The entries are stored in a linked list.
4. There is a Sequential entry that is one by one.

Which of the following applications may use a Stack?

1. A parentheses balancing program
2. Tracking of local variables at run time
3. Compiler Syntax Analyzer
4. All of these

Consider the usual algorithm for determining whether a sequence of parentheses is balanced.

The maximum number of parentheses that appear on the Stack AT ANY ONE TIME when the algorithm analyzes: (()(())(())) is:

1. 1
2. 2
3. 3
4. 4 or more

A linear list of elements in which deletion can be done from one end (front) and insertion can take place only at the other end (rear) is known as a:

1. Queue
2. Stack
3. Tree
4. Linked list

A Queue is a:

1. FIFO (First In First Out) list
2. LIFO (Last In First Out) list
3. Ordered array
4. Linear tree

What is Stack? Why is it called LIFO data structure?

List two ways to implement Stack.

Write applications of Stack.

Can a Stack be used to convert a decimal number into a binary number?

Write an algorithm to push an element into the Stack.

Write an algorithm to pop an element from the Stack.

Write an interactive menu-driven program implementing Stack using list. The list is storing numeric data.

def push(num):
    h = int(input("Enter a number: "))
    num.append(h)

def pop(num):
    if len(num) == 0:
        print("No number to delete")
    else:
        print("Deleted number is:", num.pop())

def display(num):
    print(num)

num = []
while True:
    print("1. Add number")
    print("2. Delete number")
    print("3. Display numbers")
    print("4. Exit")
    op = int(input("Enter the Choice: "))
    if op == 1:
        push(num)
    elif op == 2:
        pop(num)
    elif op == 3:
        display(num)
    elif op == 4:
        print("Exiting program.")
        break
    else:
        print("Invalid choice. Please enter a number between 1 and 4.")

1. Add number
2. Delete number
3. Display numbers
4. Exit
Enter the Choice: 1
Enter a number: 2
1. Add number
2. Delete number
3. Display numbers
4. Exit
Enter the Choice: 1
Enter a number: 4
1. Add number
2. Delete number
3. Display numbers
4. Exit
Enter the Choice: 1
Enter a number: 6
1. Add number
2. Delete number
3. Display numbers
4. Exit
Enter the Choice: 1
Enter a number: 8
1. Add number
2. Delete number
3. Display numbers
4. Exit
Enter the Choice: 3
[2, 4, 6, 8]
1. Add number
2. Delete number
3. Display numbers
4. Exit
Enter the Choice: 2
Deleted number is: 8
1. Add number
2. Delete number
3. Display numbers
4. Exit
Enter the Choice: 3
[2, 4, 6]
1. Add number
2. Delete number
3. Display numbers
4. Exit
Enter the Choice: 4
Exiting program.

Write an interactive menu-driven program to implement Stack using list. The list contains the names of students.

def push(student):
    h = input("Enter a name: ")
    student.append(h)

def pop(student):
    if len(student) == 0:
        print("No name to delete")
    else:
        print("Deleted name is:", student.pop())

def display(student):
    print(student)

student = []
while True:
    print("1. Add name")
    print("2. Delete name")
    print("3. Display names")
    print("4. Exit")
    op = int(input("Enter the Choice: "))
    if op == 1:
        push(student)
    elif op == 2:
        pop(student)
    elif op == 3:
        display(student)
    elif op == 4:
        print("Exiting program.")
        break
    else:
        print("Invalid choice. Please enter a number between 1 and 4.")

1. Add name
2. Delete name
3. Display names
4. Exit
Enter the Choice: 1
Enter a name: Prajwal
1. Add name
2. Delete name
3. Display names
4. Exit
Enter the Choice: 1
Enter a name: Amrita
1. Add name
2. Delete name
3. Display names
4. Exit
Enter the Choice: 1
Enter a name: Kavya
1. Add name
2. Delete name
3. Display names
4. Exit
Enter the Choice: 1
Enter a name: Drishti
1. Add name
2. Delete name
3. Display names
4. Exit
Enter the Choice: 3
['Prajwal', 'Amrita', 'Kavya', 'Drishti']
1. Add name
2. Delete name
3. Display names
4. Exit
Enter the Choice: 2
Deleted name is: Drishti
1. Add name
2. Delete name
3. Display names
4. Exit
Enter the Choice: 3
['Prajwal', 'Amrita', 'Kavya']
1. Add name
2. Delete name
3. Display names
4. Exit
Enter the Choice: 4
Exiting program.

How does FIFO describe queue?

Write a menu-driven Python program using queue to implement movement of shuttlecock in its box.

queue = []

def display_queue():
    if not queue:
        print("Queue is empty")
    else:
        print("Current queue:", queue)

def enqueue(item):
    queue.append(item)

def dequeue():
    if queue:
        removed = queue.pop(0)
        print("Removed", removed, "from the queue")
    else:
        print("Queue is empty, cannot remove")

while True:
    print("\nMENU:")
    print("1. Add movement to the queue")
    print("2. Remove movement from the queue")
    print("3. Display current queue")
    print("4. Exit")
    
    choice = input("Enter your choice (1-4): ")

    if choice == '1':
        movement = input("Enter the movement (up/down): ")
        enqueue(movement)
        print("Added", movement, "to the queue")
    elif choice == '2':
        dequeue()
    elif choice == '3':
        display_queue()
    elif choice == '4':
        print("Exiting program...")
        break
    else:
        print("Invalid choice, please try again")

MENU:
1. Add movement to the queue
2. Remove movement from the queue
3. Display current queue
4. Exit
Enter your choice (1-4): 1
Enter the movement (up/down): up
Added up to the queue

MENU:
1. Add movement to the queue
2. Remove movement from the queue
3. Display current queue
4. Exit
Enter your choice (1-4): 1
Enter the movement (up/down): down
Added down to the queue

MENU:
1. Add movement to the queue
2. Remove movement from the queue
3. Display current queue
4. Exit
Enter your choice (1-4): 3
Current queue: ['up', 'down']

MENU:
1. Add movement to the queue
2. Remove movement from the queue
3. Display current queue
4. Exit
Enter your choice (1-4): 2
Removed up from the queue

MENU:
1. Add movement to the queue
2. Remove movement from the queue
3. Display current queue
4. Exit
Enter your choice (1-4): 3
Current queue: ['down']

MENU:
1. Add movement to the queue
2. Remove movement from the queue
3. Display current queue
4. Exit
Enter your choice (1-4): 4
Exiting program...

Give the necessary declaration of a list implemented Stack containing float type numbers. Also, write a user-defined function to pop a number from this Stack.

# Declaration for list implemented stack
Stack = list()
#Function body to pop a number from the stack
def pop_element(Stack):
    if not Stack:
        print("Stack is empty")
    else:
        Num = Stack.pop() 
        print("Value deleted from stack is", Num)
        
    

Stack = [1.5, 2.7, 3.2, 4.9]
print("Initial Stack:", Stack)

pop_element(Stack)
print("Stack after pop operation:", Stack)

Initial Stack: [1.5, 2.7, 3.2, 4.9]
Value deleted from stack is 4.9
Stack after pop operation: [1.5, 2.7, 3.2]

A linear Stack called Directory contains the following information as contacts:

— Pin code of city
— Name of city

Write add(Directory) and delete(Directory) methods in Python to add and remove contacts using append() and pop() operations in Stack.

def add(Directory):
    pincode = int(input("Enter pincode of city: "))
    cityname = input("Enter the city name: ")
    contact = [pincode, cityname]
    Directory.append(contact)

def delete(Directory):
    if (Directory == []):
        print("Directory is empty")
    else:
        print("Deleted contact:", Directory.pop())
        
Directory = []
add(Directory)
add(Directory)
print("Initial Directory Stack:", Directory)

delete(Directory)
print("Directory Stack after deletion:", Directory)

Enter pincode of city: 586789
Enter the city name: Bangalore
Enter pincode of city: 567890
Enter the city name: Mysore
Initial Directory Stack: [[586789, 'Bangalore'], [567890, 'Mysore']]
Deleted contact: [567890, 'Mysore']
Directory Stack after deletion: [[586789, 'Bangalore']]

Write add(Books) and delete(Books) methods in Python to add Books and Remove Books considering them to act as append() and pop() operations in Stack.

def add(Books):
    bookname = input("Enter the book name: ")
    Books.append(bookname)

def delete(Books):
    if Books == []:
        print("Books is empty")
    else:
        print("Deleted Book", Books.pop())
        
Books = []

add(Books)
add(Books)
add(Books)
print("Initial Books Stack:", Books)


delete(Books)
print("Books Stack after deletion:", Books)

Enter the book name: Three thousand stitches
Enter the book name: Wings of fire
Enter the book name: Ignited minds
Initial Books Stack: ['Three thousand stitches', 'Wings of fire', 'Ignited minds']
Deleted Book Ignited minds
Books Stack after deletion: ['Three thousand stitches', 'Wings of fire']

Write AddClient(Client) and DeleteClient(Client) methods in Python to add a new client and delete a client from a list client name, considering them to act as insert and delete operations of the Queue data structure.

def AddClient(client):
    client_name = input("Enter client name: ")
    client.append(client_name)

def DeleteClient(client):
    if client == []:
        print("Queue is empty")
    else:
        print("Deleted client:", client.pop(0))

client = []

AddClient(client)
AddClient(client)
AddClient(client)
print("Initial Client Queue:", client)

DeleteClient(client)
print("Client Queue after deletion:", client)

Enter client name: Rahul
Enter client name: Tanvi
Enter client name: Vidya
Initial Client Queue: ['Rahul', 'Tanvi', 'Vidya']
Deleted client: Rahul
Client Queue after deletion: ['Tanvi', 'Vidya']

Write Addscore(Game) and Delscore(Game) methods in Python to add new Score in the list of score in a game and remove a score from a list of score of a game considering these methods to act as PUSH and POP operation of data structure Stack.

def Addscore(Game):
    score = int(input("Enter the score to add: "))
    Game.append(score)

def Delscore(Game):
    if Game == []:
        print("Game's score list is empty")
    else: 
        print("Deleted score:", Game.pop())

Game = []

Addscore(Game)
Addscore(Game)
Addscore(Game)
print("Initial Game Stack:", Game)

Delscore(Game)
print("Game Stack after deletion:", Game)

Enter the score to add: 10
Enter the score to add: 15
Enter the score to add: 20
Initial Game Stack: [10, 15, 20]
Deleted score: 20
Game Stack after deletion: [10, 15]

Write a Python program to sort a Stack in ascending order without using an additional Stack.

def pushSorted(s, num):
	if len(s) == 0 or num > s[-1]:
		s.append(num)
		return
	else:
		t = s.pop()
		pushSorted(s, num)
		s.append(t)

def doSort(s):
	if len(s) != 0:
		t = s.pop()
		doSort(s)
		pushSorted(s, t)

s = []
s.append(12)
s.append(5)
s.append(-3)
s.append(4)
s.append(10)

print("Stack before sorting: ")
print(s)

doSort(s)

print("\nStack after sorting: ")
print(s)

Stack before sorting: 
[12, 5, -3, 4, 10]

Stack after sorting:
[-3, 4, 5, 10, 12]

A Stack STK and Queue QUE is being maintained. Their maximum size is the same:

(i) check whether they have the same size, i.e., have the same number of elements.

(ii) check for equality of Stack and Queue, i.e.,

1. Retrieve an element from the Stack and one element from the Queue.
2. Compare the two.
3. Stop and report if elements are different.

def is_empty(stack_or_queue):
    return len(stack_or_queue) == 0

def size(stack_or_queue):
    return len(stack_or_queue)

def check_size_equality(stack, queue):
    return size(stack) == size(queue)

def check_element_equality(stack, queue):
    if check_size_equality(stack, queue) == False:
        print("The size of stack and Queue is not equal.")
        return False
    
    while not is_empty(stack) and not is_empty(queue):
        stack_element = stack.pop()
        queue_element = queue.pop(0)

        if stack_element != queue_element:
            return False

    return True

STK = [1, 2, 3]
QUE = [3, 2, 1]

print("Size Equality Check:", check_size_equality(STK, QUE))

print("Element Equality Check:", check_element_equality(STK, QUE))

Size Equality Check: True
Element Equality Check: True

Write an algorithm to insert element into Stack as a list.

Write an algorithm to insert element into Queue as a list.

Write a program to create a Stack for storing only odd numbers out of all the numbers entered by the user. Display the content of the Stack along with the largest odd number in the Stack.

(Hint: Keep popping out the elements from Stack and maintain the largest element retrieved so far in a variable. Repeat till Stack is empty.)

def push(stack, item):
    stack.append(item)

def pop(stack):
    if stack == []:
        return None
    return stack.pop()

def oddStack(num):
    if num % 2 == 1:
        push(stack, num)

def GetLargest(stack):
    elem = pop(stack)
    large = elem
    while elem != None:
        if large < elem:
            large = elem
        elem = pop(stack)
    return large

n = int(input("How many numbers?"))
stack = []
for i in range(n):
    number = int(input("Enter number:"))
    oddStack(number)
print("Stack created is", stack)
bigNum = GetLargest(stack)
print("Largest number in stack", bigNum)

How many numbers?8
Enter number:1
Enter number:2
Enter number:3
Enter number:4
Enter number:5
Enter number:6
Enter number:7
Enter number:8
Stack created is [1, 3, 5, 7]
Largest number in stack 7

Write a program that, depending upon the user's choice, either adds or removes an element from a Stack.

def add(stack):
    h = input("Enter element: ")
    stack.append(h)

def remove(stack):
    if len(stack) == 0:
        print("No element to delete")
    else:
        print("Deleted element is:", stack.pop())


stack = []
while True:
    print("1. Add element")
    print("2. Delete element")
    print("3. Exit")
    op = int(input("Enter the Choice: "))
    if op == 1:
        add(stack)
    elif op == 2:
        remove(stack)
    elif op == 3:
        print("Exiting program.")
        break

1. Add element
2. Delete element
3. Exit
Enter the Choice: 1
Enter element: 11
1. Add element
2. Delete element
3. Exit
Enter the Choice: 1
Enter element: 33
1. Add element
2. Delete element
3. Exit
Enter the Choice: 1
Enter element: 44
1. Add element
2. Delete element
3. Exit
Enter the Choice: 2
Deleted element is: 44
1. Add element
2. Delete element
3. Exit
Enter the Choice: 1
Enter element: 55
1. Add element
2. Delete element
3. Exit
Enter the Choice: 2
Deleted element is: 55
1. Add element
2. Delete element
3. Exit
Enter the Choice: 3
Exiting program.

Write a program that, depending upon the user's choice, either pushes or pops an element in a Stack. The elements are shifted towards the right so that the top always remains at 0th (zeroth) index.

def push(stack, element):
    stack.insert(0, element)  

def pop(stack):
    if stack == []:
        print("Stack is empty")
    else:
        print("Popped element:", stack.pop(0))


stack = []

while True:
    print("STACK OPERATIONS")
    print("1. Push element")
    print("2. Pop element")
    print("3. Exit")
    choice = input("Enter your choice (1-3): ")

    if choice == '1':
        element = input("Enter the element to push: ")
        push(stack, element)
    elif choice == '2':
        pop(stack)
    elif choice == '3':
        print("Exiting program")
        break
    else:
        print("Invalid choice. Please enter a valid option.")

STACK OPERATIONS
1. Push element
2. Pop element
3. Exit
Enter your choice (1-3): 1
Enter the element to push: 3
STACK OPERATIONS
1. Push element
2. Pop element
3. Exit
Enter your choice (1-3): 1
Enter the element to push: 6
STACK OPERATIONS
1. Push element
2. Pop element
3. Exit
Enter your choice (1-3): 1
Enter the element to push: 9
STACK OPERATIONS
1. Push element
2. Pop element
3. Exit
Enter your choice (1-3): 1
Enter the element to push: 12
STACK OPERATIONS
1. Push element
2. Pop element
3. Exit
Enter your choice (1-3): 2
Popped element: 12
STACK OPERATIONS
1. Push element
2. Pop element
3. Exit
Enter your choice (1-3): 3
Exiting program

Write a program to insert or delete an element from a Queue depending upon the user's choice. The elements are not shifted after insertion or deletion.

def enqueue(queue):
    element = input("Enter the element to enqueue: ")
    queue.append(element)  

def dequeue(queue):
    if queue:
        removed_element = queue.pop(0) 
        print("Dequeued element:", removed_element)
    else:
        print("Queue is empty")

queue = []

while True:
    print("QUEUE OPERATIONS")
    print("1. Enqueue element")
    print("2. Dequeue element")
    print("3. Exit")
    choice = input("Enter your choice (1-3): ")

    if choice == '1':
        enqueue(queue)
    elif choice == '2':
        dequeue(queue)
    elif choice == '3':
        print("Exiting program")
        break
    else:
        print("Invalid choice. Please enter a valid option.")

QUEUE OPERATIONS
1. Enqueue element
2. Dequeue element
3. Exit
Enter your choice (1-3): 1
Enter the element to enqueue: 4
QUEUE OPERATIONS
1. Enqueue element
2. Dequeue element
3. Exit
Enter your choice (1-3): 1
Enter the element to enqueue: 8
QUEUE OPERATIONS
1. Enqueue element
2. Dequeue element
3. Exit
Enter your choice (1-3): 1
Enter the element to enqueue: 12
QUEUE OPERATIONS
1. Enqueue element
2. Dequeue element
3. Exit
Enter your choice (1-3): 2
Dequeued element: 4
QUEUE OPERATIONS
1. Enqueue element
2. Dequeue element
3. Exit
Enter your choice (1-3): 3
Exiting program

Two lists Lname and Lage contain name of person and age of person respectively. A list named Lnameage is empty. Write functions as per details given below:

1. Push_na(): It will push the tuple containing pair of name and age from Lname and Lage whose age is above 50.
2. Pop_na(): It will remove the last pair of name and age and also print name and age of the removed person. It should also print "underflow" if there is nothing to remove.

For example, the two lists have the following data:

Lname=['Narender', 'Jaya', 'Raju', 'Ramesh', 'Amit', 'Piyush' ]
Lage= [45, 23, 59, 34, 51, 43]

After Push_na() the Lnameage Stack contains:

[('Raju', 59), ('Amit', 51)]

The output of first execution of Pop_na() is:

The name removed is Amit
The age of person is 51

def Push_na(Lname, Lage, Lnameage):
    for i in range(len(Lname)):
        if Lage[i] > 50:
            Lnameage.append((Lname[i], Lage[i]))

def Pop_na(Lnameage):
    if Lnameage:
        removed_name, removed_age = Lnameage.pop()
        print("The name removed is", removed_name)
        print("The age of person is", removed_age)
    else:
        print("Underflow - Nothing to remove")

Lname = ['Narender', 'Jaya', 'Raju', 'Ramesh', 'Amit', 'Piyush']
Lage = [45, 23, 59, 34, 51, 43]
Lnameage = []

Push_na(Lname, Lage, Lnameage)
print("After Push_na() the Lnameage Stack contains:")
print(Lnameage)

print("\nThe output of first execution of Pop_na() is:")
Pop_na(Lnameage)

After Push_na() the Lnameage Stack contains:
[('Raju', 59), ('Amit', 51)]

The output of first execution of Pop_na() is:
The name removed is Amit
The age of person is 51

A dictionary stu contains rollno and marks of students. Two empty lists stack_roll and stack_mark will be used as Stack. Two functions Push_stu() and Pop_stu() are defined and perform the following operation:

1. Push_stu(): It reads dictionary stu and adds keys into stack_roll and values into stack_marks for all students who secured more than 60 marks.
2. Pop_stu(): It removes last rollno and marks from both list and prints "underflow" if there is nothing to remove.

For example,

stu={ 1 : 56, 2 : 45, 3 : 78, 4 : 65, 5 : 35, 6 : 90 }

Values of stack_roll and stack_mark after push_stu() function:

[3, 4, 6] and {78, 65, 90}

def Push_stu(stu, stack_roll, stack_mark):
    for rollno, marks in stu.items():
        if marks > 60:
            stack_roll.append(rollno)
            stack_mark.append(marks)

def Pop_stu(stack_roll, stack_mark):
    if stack_roll and stack_mark:
        print("Removed rollno:", stack_roll.pop())
        print("Removed marks:", stack_mark.pop())
    else:
        print("Underflow - Nothing to remove")

stu = {1: 56, 2: 45, 3: 78, 4: 65, 5: 35, 6: 90}
stack_roll = []
stack_mark = []

Push_stu(stu, stack_roll, stack_mark)
print("Values of stack_roll and stack_mark after Push_stu() function:")
print(stack_roll, stack_mark)

print("\nThe output of first execution of Pop_stu() is:")
Pop_stu(stack_roll, stack_mark)

Values of stack_roll and stack_mark after Push_stu() function:
[3, 4, 6] [78, 65, 90]

The output of first execution of Pop_stu() is:
Removed rollno: 6
Removed marks: 90

Write AddCustomer(Customer) and DeleteCustomer(Customer) methods in Python to add a new Customer and delete a Customer from a List of CustomerNames, considering them to act as push and pop operations of the Stack data structure.

def AddCustomer(Customer):
    Customer_name = input("Enter the customer name: ")
    Customer.append(Customer_name)

def DeleteCustomer(Customer):
    if Customer == []:
        print("Customer list is empty")
    else: 
        print("Deleted Customer name:", Customer.pop())

Customer = []

AddCustomer(Customer)
AddCustomer(Customer)
AddCustomer(Customer)
print("Initial Customer Stack:", Customer)

DeleteCustomer(Customer)
print("Customer Stack after deletion:", Customer)

Enter the customer name: Anusha
Enter the customer name: Sandeep
Enter the customer name: Prithvi
Initial Customer Stack: ['Anusha', 'Sandeep', 'Prithvi']
Deleted Customer name: Prithvi
Customer Stack after deletion: ['Anusha', 'Sandeep']

Single-ended linear structure is a type of queue data structure.

Reversing a word/line is an application of Stack.

The insertion and deletion from a Stack takes place only from the 'TOP'.

A queue behaves on the basis of LIFO principle.

When a queue is implemented with the help of a list, it is termed as a linear queue.

Deletion of an element from the queue is termed as pop operation.

An element to a queue is added from the front end.

Handling the processes of a network printer is the most important application of queues.

The append() function inserts an element at the rear end in a queue.

Stack is a linear data structure.

PUSH operation may result in underflow condition.