# What Is Linked Stack in Data Structure?

//

Scott Campbell

A linked stack is a type of data structure that follows the Last-In-First-Out (LIFO) principle. It is similar to a stack, but instead of using an array to store the elements, it uses linked nodes.

Each node contains both the element and a reference to the next node in the stack. This allows for efficient insertion and deletion operations, as well as dynamic memory allocation.

How Does a Linked Stack Work?

A linked stack consists of nodes that are linked together in a chain-like structure. The first node in the chain is called the top of the stack.

When an element is added to the stack, it creates a new node and links it to the current top node. The new node then becomes the top of the stack. Similarly, when an element is removed from the stack, the top node is unlinked and replaced by its next node in line.

• Dynamic Size: Unlike arrays, linked stacks can dynamically grow or shrink as elements are added or removed.
• Efficient Operations: Adding or removing elements from a linked stack has a time complexity of O(1) since it only involves updating references.
• No Overflow: Linked stacks do not have an overflow problem since they can allocate memory as needed.

To implement a linked stack, you need to define a class or structure for each node and another class or structure for managing the stack operations:

### Node Structure

“`html

``````
struct Node {
int data;
Node* next;
};
```
```

“`

“`html

``````
private:
Node* top;

public:
top = nullptr;
}

void push(int element) {
Node* newNode = new Node;
newNode->data = element;
newNode->next = top;
top = newNode;
}

void pop() {
if (isEmpty()) {
cout << "Stack is empty." << endl;
return;
}

Node* temp = top;
top = top->next;
delete temp;
}

int peek() {
if (isEmpty()) {
cout << "Stack is empty." << endl;
return -1; // Or any other appropriate value
}

}

bool isEmpty() {
return (top == nullptr);
}

};
```
```

“`

Conclusion

A linked stack is a versatile data structure that provides dynamic size, efficient operations, and avoids overflow problems. It can be implemented using linked nodes and offers various stack operations like push, pop, peek, and isEmpty. Understanding linked stacks is important for anyone working with data structures or algorithms that require LIFO behavior.