Write a Python program to implement stack using list

Python Program to Implement a Stack using Linked List

PythonServer Side ProgrammingProgramming

When it is required to implement a stack data structure using a linked list, a method to add (push values) elements to the linked list, and a method to delete (pop values) the elements of the linked list are defined.

Below is a demonstration for the same −

Using List as Stack and Queues in Python

PythonServer Side ProgrammingProgramming

In this article, we will learn about Stack & Queue structures in Python 3.x. Or earlier. Here we will discuss the working and modification within these data structures −

This includes −

1. Insertion operation (Push, Enqueue)
2. Deletion operation (Pop, Dequeue)
3. Display / Traversing Operation

Prerequisites: List & List Operations

Related Data Structure: List Manipulation

How to implement stack in Python

A stack is a last-in-first-out (LIFO) data structure. It has three primitive operations:

• Push: Add an element to the stack
• Pop: Remove an element from the stack
• Peek: Get the topmost element of the stack

stack

In Python, a stack is implemented using a list object.

• To push an item in the stack, use the list function append list.append(item)
• To pop an item in the stack, use the list function pop list.pop()
• To get the top most item in the stack, write list[-1]

The following illustration explains the concept:

1 of 6

1 of 6

1 of 6

1 of 6

1 of 6

4.5. Implementing a Stack in Python¶

Now that we have clearly defined the stack as an abstract data type we will turn our attention to using Python to implement the stack. Recall that when we give an abstract data type a physical implementation we refer to the implementation as a data structure.

As we described in Chapter 1, in Python, as in any object-oriented programming language, the implementation of choice for an abstract data type such as a stack is the creation of a new class. The stack operations are implemented as methods. Further, to implement a stack, which is a collection of elements, it makes sense to utilize the power and simplicity of the primitive collections provided by Python. We will use a list.

Recall that the list class in Python provides an ordered collection mechanism and a set of methods. For example, if we have the list [2,5,3,6,7,4], we need only to decide which end of the list will be considered the top of the stack and which will be the base. Once that decision is made, the operations can be implemented using the list methods such as append and pop.

The following stack implementation (ActiveCode 1) assumes that the end of the list will hold the top element of the stack. As the stack grows (as push operations occur), new items will be added on the end of the list. pop operations will manipulate that same end.

Remember that nothing happens when we click the run button other than the definition of the class. We must create a Stack object and then use it. ActiveCode 2 shows the Stack class in action as we perform the sequence of operations from Table 1. Notice that the definition of the Stack class is imported from the pythonds module.

Note

The pythonds module contains implementations of all data structures discussed in this book. It is structured according to the sections: basic, trees, and graphs. The module can be downloaded from GitHub. or installed from the command line using pip install pythonds.

It is important to note that we could have chosen to implement the stack using a list where the top is at the beginning instead of at the end. In this case, the previous pop and append methods would no longer work and we would have to index position 0 (the first item in the list) explicitly using pop and insert. The implementation is shown in CodeLens 1.

Activity: CodeLens Alternative Implementation of the Stack class (stack_cl_1)

This ability to change the physical implementation of an abstract data type while maintaining the logical characteristics is an example of abstraction at work. However, even though the stack will work either way, if we consider the performance of the two implementations, there is definitely a difference. Recall that the append and pop() operations were both O(1). This means that the first implementation will perform push and pop in constant time no matter how many items are on the stack. The performance of the second implementation suffers in that the insert(0) and pop(0) operations will both require O(n) for a stack of size n. Clearly, even though the implementations are logically equivalent, they would have very different timings when performing benchmark testing.

Self Check

Q-4: Given the following sequence of stack operations, what is the top item on the stack when the sequence is complete?

m = Stack() m.push('x') m.push('y') m.pop() m.push('z') m.peek()

• 'x'
• Remember that a stack is built from the bottom up.
• 'y'
• Remember that a stack is built from the bottom up.
• 'z'
• Good job.
• The stack is empty
• Remember that a stack is built from the bottom up.

Q-5: Given the following sequence of stack operations, what is the top item on the stack when the sequence is complete?

m = Stack() m.push('x') m.push('y') m.push('z') while not m.isEmpty(): m.pop() m.pop()

• 'x'
• You may want to check out the docs for isEmpty
• the stack is empty
• There is an odd number of things on the stack but each time through the loop 2 things are popped.
• an error will occur
• Good Job.
• 'z'
• You may want to check out the docs for isEmpty

Write a function revstring(mystr) that uses a stack to reverse the characters in a string.

Top-Paying Programming Certifications for 2022

By KnowledgeHut