Scribd
Upload
5 views5 pages

Java Stack Implementation Example

Uploaded by

Inbavalli Rajendran
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
5 views5 pages

Java Stack Implementation Example

Uploaded by

Inbavalli Rajendran
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd

class Node

{
int data; // integer data
Node next; // pointer to the next node
}
class Stack
{
private Node top;

public Stack()
{
[Link] = null;
}

// Utility function to add an element `x` to the stack


public void push(int x) // insert at the beginning
{
// allocate a new node in a heap
Node node = new Node();

// check if stack (heap) is full. Then inserting an element


would
// lead to stack overflow
if (node == null)
{
[Link]("\nHeap Overflow");
return;
}

[Link]("Inserting " + x);

// set data in the allocated node


[Link] = x;

// set the `.next` pointer of the new node to point to the


current
// top node of the list
[Link] = top;

// update top pointer


top = node;
}

// Utility function to check if the stack is empty or not


public boolean isEmpty() {
return top == null;
}

// Utility function to return the top element of the stack


public int peek()
{
// check for an empty stack
if (!isEmpty()) {
return [Link];
}
else {
[Link]("The stack is empty");
return -1;
}
}

// Utility function to pop a top element from the stack


public void pop() // remove at the beginning
{
// check for stack underflow
if (top == null)
{
[Link]("\nStack Underflow");
return;
}
[Link]("Removing " + peek());

// update the top pointer to point to the next node


top = (top).next;
}
}
class Main
{
public static void main(String[] args)
{
Stack stack = new Stack();

[Link](1);
[Link](2);
[Link](3);

[Link]("The top element is " + [Link]());

[Link]();
[Link]();
[Link]();

if ([Link]()) {
[Link]("The stack is empty");
}
else {
[Link]("The stack is not empty");
}
}
}

Common questions

Powered by AI

To improve error reporting, exceptions could be used instead of simple print statements. For example, a custom StackOverflowException could be thrown when node allocation fails during a push operation. Similarly, a StackUnderflowException could replace the 'Stack Underflow' message during erroneous pop attempts, allowing better integration with Java's error handling framework .

The push operation checks for heap overflow by verifying if a new Node can be allocated. If node allocation fails (node == null), it indicates that inserting a new element would lead to stack overflow, and the function outputs 'Heap Overflow' to notify the user .

During a pop operation, the stack first checks for underflow by verifying if the top is null. If underflow occurs, it prints 'Stack Underflow.' Otherwise, it retrieves the current top element using the peek function, displays it, and updates the top pointer to point to the next node, effectively removing the top element .

This implementation may be limited by heap size, which could restrict the stack size due to fixed memory allocation. Additionally, the overhead of Node objects and dynamic memory allocation per operation could cause inefficiencies. It lacks built-in handling for stack memory growth, making stack overflow errors likely in high-load scenarios .

When inserting a new element, a new Node is allocated. The data is set in this node, and its `.next` pointer is set to the current top of the stack. Finally, the top pointer is updated to this new node, maintaining the link between nodes by pointing to the previously top node as the new node's `.next` .

A size method can be added by maintaining a size counter in the Stack class. This counter should increment with each successful push and decrement with each pop. The size method would simply return this counter's value, providing O(1) time complexity for retrieving stack size .

Checking if the stack is empty before peeping prevents accessing an undefined element which could cause errors. If the stack is empty, the function prints 'The stack is empty' and returns -1, serving as a sentinel value to indicate the lack of elements .

Checking for stack underflow is crucial to prevent removing elements from an already-empty stack, which could result in accessing uninitialized memory. In this implementation, if the top is null, a message 'Stack Underflow' is printed, and the operation terminates without further action .

The 'main' method serves as a test harness for demonstrating stack operations. It initializes a stack, performs a series of push operations with elements 1, 2, and 3, checks the top element, performs consecutive pop operations, and finally checks if the stack is empty, helping verify the correct implementation of stack functionality .

Updating the top pointer is necessary to remove the top element from the stack. By pointing the top to the next node, the reference to the current top node is discarded, effectively unlinking it from the stack and allowing garbage collection to reclaim space, maintaining the stack's integrity .

You might also like