Stacks (Program 4) – Part 1

Introduction to Reversing a Stack Using Two Stacks

In this section, the lecturer introduces the topic of reversing a stack using two temporary stacks. The goal is to reverse all the elements of the original stack by utilizing two temporary stacks.

Understanding the Problem

• The lecturer explains that the objective is to write a program that reverses the elements of a stack.

• Three stacks are involved: the original stack, and two temporary stacks.

• The pictorial representation shows the original stack at one end and two temporary stacks at the other end.

Reversing Elements of the Stack

• The lecturer demonstrates how reversing should look like, with one being at the topmost position, followed by two and three.

• The idea is to pop elements from the original stack and push them onto temporary stack one.

• This process continues until all elements are moved from the original stack to temporary stack one.

Moving Elements to Temporary Stack Two

• After pushing all elements onto temporary stack one, they need to be moved to temporary stack two.

• Elements are popped from temporary stack one and pushed into temporary stack two.

Conclusion

In this section, we conclude our understanding of reversing a stack using two stacks.

Summary

• The process involves popping elements from the original stack and pushing them onto temporary stack one.

• Once all elements are on temporary stack one, they are then popped and pushed onto temporary stack two in reverse order.

By following these steps, we can successfully reverse all elements in a given stack using only two additional stacks.

New Section

This section focuses on implementing the original stack and understanding the push function.

Implementing the Original Stack

• To implement the original stack, a global declaration of the top pointer is made.

• The push function is called three times in the main function to insert elements onto the original stack.

• The push function receives data as input and updates the data part of a new node with that data.

• The Melok function is called after updating the data part.

• If the new node is null, it means there was an error in creating the node.

• After executing all necessary lines of code, the link part of the new node is updated by top.

New Section

This section introduces a program to reverse a stack using two temporary stacks.

Reversing a Stack Using Two Temporary Stacks

• The goal is to reverse all elements of an original stack with two temporary stacks.

• The complete code for this program will be shown in code blocks.

• A global declaration of top pointer for stuck nodes is made.

• An isEmpty() function checks if the stack is empty or not. It returns 1 if empty and 0 otherwise.

• The push() function adds elements to a stack, while print() prints all elements of a stack.

• In main(), three stacks are represented: original stack, temporary stack one, and temporary stack two.

New Section

This section demonstrates how to print and reverse elements in a stack.

Printing and Reversing Elements in a Stack

• The program starts by pushing three elements (3, 2, 1) onto the original stack using push().

• Then print() is called to display all elements of the original stack (3, 2, 1).

• The goal is to reverse the elements of the original stack.

• The program successfully prints the stack elements as 3, 2, and 1.

New Section

This section discusses the challenge of creating multiple stacks and the objective of reversing stack elements.

Creating Multiple Stacks and Reversing Elements

• The question arises about how to create more than one stack in C code.

• The main objective is to write a program that reverses the elements of an original stack.

• Global declarations of top pointers for multiple stacks are considered.

• Reversing means obtaining a reversed order of elements (e.g., 1, 2, 3).

New Section

This section concludes by emphasizing the need to understand and properly address the problem requirements.

Understanding Problem Requirements

• It is crucial to understand and properly address the problem requirements before writing a program.

• The push() function adds elements to a stack, while print() displays all elements in a stack.

• The main function calls push() three times with different values (1, 2, 3) and then calls print().

• The program successfully displays the original stack's elements as 3, 2, and 1.

Understanding the Push Function

This section explains the functionality of the push function in a program.

The Push Function

• The push function receives initial data as an argument.

• It assigns the value to the data variable.

• A new node pointer is declared and memory is allocated for it using the malloc function.

• If the new node is null, indicating stack overflow, the program exits with a failure status.

• If the new node is not null, the data part of the new node is updated with data, and the link part is set to null.

• Finally, the top pointer is updated to point to the new node.

Complete Program Code Explanation

This section provides an overview of the complete code for a stack implementation.

Complete Program Code

• The program includes a global declaration of a stack node top pointer.

• An isEmpty function checks if the stack is empty and returns 1 if true, or 0 if false.

• The push function adds elements to the stack by creating a new node and updating pointers accordingly.

• A print function prints all elements of the stack using a while loop.

• In main(), we call push functions to add elements and then call print function to display all elements.

Execution and Output

This section discusses executing and understanding output from running a sample program.

Execution and Output

• After executing the code, we see that there are three elements in the stack: 3 (top), 2, and 1 (bottom).

• The program successfully adds elements to the stack using push functions and displays them using print functions.