C program to Implement a Stack using Singly Linked List
/* * C Program to Implement a Stack using Linked List */ #include #include struct node { int data; struct node *next; }*top; /* Initialize an empty stack */ void initialize[] { top = NULL; } /* Checks if Stack is empty or not */ int isEmpty[] { if [top == NULL] return 1; else return 0; } /* Returns the top element of Stack */ int peek[] { return top->data; } /* Count stack elements */ int getStackSize[struct node *head]{ /* Input Validation */ if [head == NULL] { printf["Error : Invalid stack pointer !!!\n"]; return; } int length = 0; while[head != NULL]{ head = head->next; length++; } return length; } /* Push an Element in Stack */ void push[int num] { struct node *temp; temp =[struct node *]malloc[1*sizeof[struct node]]; temp->data = num; if [top == NULL] { top = temp; top->next = NULL; } else { temp->next = top; top = temp; } } /* Pop Operation: Removes Top Element of the Stack */ void pop[] { struct node *temp; if [isEmpty[top]] { printf["\nStack is Empty\n"]; return; } else { temp = top; top = top->next; printf["Removed Element : %d\n", temp->data]; free[temp]; } } /* Prints the linked list representation of a stack */ void printStack[struct node *nodePtr] { while [nodePtr != NULL] { printf["%d", nodePtr->data]; nodePtr = nodePtr->next; if[nodePtr != NULL] printf["-->"]; } printf["\n"]; } void main[] { /* Initialize Stack */ initialize[]; /* Push Elements in stack */ push[1]; push[2]; push[3]; push[4]; /* Prints Size of Stack */ printf["Stack Size : %d\n", getStackSize[top]]; /* Printing top element of Stack */ printf["\nTop Element : %d\n", peek[]]; /* Printing Stack */ printf["Stack as linked List\n"]; printStack[top]; /* Removing elements from stack */ pop[]; pop[]; pop[]; pop[]; pop[]; printStack[top]; return; } OutputStack Size : 4 Top Element : 4 Stack as linked List 4-->3-->2-->1 Removed Element : 4 Removed Element : 3 Removed Element : 2 Removed Element : 1 Stack is Empty
Implement a stack using singly linked list
To implement a stack using singly linked list concept , all the singly linked list operations are performed based on Stack operations LIFO[last in first out] and with the help of that knowledge we are going to implement a stack using single linked list. Using singly linked lists , we implement stack by storing the information in the form of nodes and we need to follow the stack rules and implement using singly linked list nodes . So we need to follow a simple rule in the implementation of a stack which is last in first out and all the operations can be performed with the help of a top variable .Let us learn how to perform Pop , Push , Peek ,Display operations in the following article .
A stack can be easily implemented using the linked list. In stack Implementation, a stack contains a top pointer. which is “head” of the stack where pushing and popping items happens at the head of the list. First node have null in link field and second node link have first node address in link field and so on and last node address in “top” pointer.
The main advantage of using linked list over an arrays is that it is possible to implement a stack that can shrink or grow as much as needed. In using array will put a restriction to the maximum capacity of the array which can lead to stack overflow. Here each new node will be dynamically allocate. so overflow is not possible.
Stack Operations:
- push[] : Insert a new element into stack i.e just inserting a new element at the beginning of the linked list.
- pop[] : Return top element of the Stack i.e simply deleting the first element from the linked list.
- peek[]: Return the top element.
- display[]: Print all elements in Stack.
Below is the implementation of the above approach:
|
// C++ program to Implement a stack
//using singly linked list
#include
using namespace std;
// Declare linked list node
struct Node
{
int data;
Node* link;
};
Node* top;
// Utility function to add an element
// data in the stack insert at the beginning
void push[int data]
{
// Create new node temp and allocate memory in heap
Node* temp = new Node[];
// Check if stack [heap] is full.
// Then inserting an element would
// lead to stack overflow
if [!temp]
{
cout data = data;
// Put top pointer reference into temp link
temp->link = top;
// Make temp as top of Stack
top = temp;
}
// Utility function to check if
// the stack is empty or not
int isEmpty[]
{
//If top is NULL it means that
//there are no elements are in stack
return top == NULL;
}
// Utility function to return top element in a stack
int peek[]
{
// If stack is not empty , return the top element
if [!isEmpty[]]
return top->data;
else
exit[1];
}
// Utility function to pop top
// element from the stack
void pop[]
{
Node* temp;
// Check for stack underflow
if [top == NULL]
{
cout 33->22->11->
Top element is 44
22->11->
Top element is 22
Time Complexity: The time complexity for all push[], pop[], and peek[] operations is O[1] as we are not performing any kind of traversal over the list. We perform all the operations through the current pointer only.
Article Tags :
Linked List Stack Technical Scripter
Technical Scripter 2018 Practice Tags :
Linked List Stack
Read Full Article
Linked list implementation of stackInstead of using array, we can also use linked list to implement stack. Linked list allocates the memory dynamically. However, time complexity in both the scenario is same for all the operations i.e. push, pop and peek. In linked list implementation of stack, the nodes are maintained non-contiguously in the memory. Each node contains a pointer to its immediate successor node in the stack. Stack is said to be overflown if the space left in the memory heap is not enough to create a node. The top most node in the stack always contains null in its address field. Lets discuss the way in which, each operation is performed in linked list implementation of stack. Problem DefinitionA stack can be implemented using array data structure or a dynamically growing linked-list data structures. The linked-list implementation of stack does not need to check for “stack being full” because the list grows dynamically. A linked-list has nodes that are linked together using pointers. A linked-list node has a data and a link pointer of type node that points to the next node element in the list. An example of a node struct node { int data; node* next; };Steps to build a linked-list based stack is as follows Step 1: Declare pointers to build initial stack. struct node *head, *temp;The *head pointer of type struct points to the first node of the linked-list and the *temp pointer of type struct points to any new node you create. The pointers are created but does not point to anything. You must point to some variable or allocate memory to initialize them. Step 2: Initialize the head node. In C programming language, you must initialize any pointer by dynamically allocating memory using function malloc []. You initialize pointer head as follows head =[struct node* ]malloc[ [ struct node]]Now that have assigned memory to the head node, give values to its variables. head->data=10; head->next =NULL;See the following diagram to understand what initializing a node means. The head pointer points to a location which has address 0x3000 and data value is 10. The node->next is also a pointer that maintain the linked-list and currently points to NULL. Step 3: Create a new node and *temp points to it We now create a new node by allocating memory dynamically for *temp. temp = [struct node*] malloc [[struct node]];assign values to the variable and point the next pointer to NULL. temp->data = 20; temp->next = NULL;See the memory drawing below to understand the process. Right now, we have two independent nodes, not a linked-list. To start building a list and making sure that the linked-list work like a stack. Step 4: Now temp nodes must point to head node so that it becomes the first node or head node. temp->next = head;Step 5: Write a pop [] function that removes the top element. In the stack, pop [] function directly removes the top element automatically. You need to skip the top element and make the second element as the head of the linked-list based stack. To make a new head use following code head = head->next;Stack using linked listStack using an array - drawbackIf we implement the stack using an array, we need to specify the array size at the beginning[at compile time]. We can't change the size of an array at runtime. So, it will only work for a fixed number of elements. SolutionWe can implement the stack using the linked list. In the linked list, we can change its size at runtime. Video liên quanChủ Đề |