Skip to content
Related Articles
Open in App
Not now

Related Articles

Time and Space Complexity analysis of Stack operations

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 31 Jan, 2023
Improve Article
Save Article

What is Stack?

Stack is a linear data structure that follows a particular order in which the elements are inserted and deleted. A stack follows the principle of last in first out(LIFO) which means that the last element inserted into the stack should be removed first. Consider an example of plates stacked over one another in the canteen. The plate which is at the top is the first one to be removed, i.e. the plate which has been placed at the bottommost position remains in the stack for the longest period of time. So, it can be simply seen to follow LIFO(Last In First Out)/FILO(First In Last Out) order. A stack can be implemented using Arrays or Linked Lists.

Complexity analysis of different stack operations:

1) push():

This operation pushes an element on top of the stack and the top pointer points to the newly pushed element. It takes one parameter and pushes it onto the stack.

Below is the implementation of push() using Array :

C++




#include <bits/stdc++.h>
using namespace std;
 
class Stack {
public:
    int stack[10];
    int MAX = 10;
    int top;
 
    Stack() { top = -1; }
 
    void push(int val)
    {
        // If top is pointing to
        // maximum size of stack
        if (top >= MAX - 1) {
 
            // Stack is full
            cout << "Stack Overflow\n";
            return;
        }
 
        // Point top to new top
        top++;
 
        // Insert new element at top of stack
        stack[top] = val;
        cout << val
             << " pushed into stack successfully !\n";
    }
};
 
int main()
{
    Stack st;
    st.push(1);
    st.push(2);
    return 0;
}


Java




// Java code to push element on top of stack
 
import java.io.*;
 
class GFG {
 
    static class Stack {
        int stack[] = new int[10];
        int MAX = 10;
        int top;
 
        void stack() { top = -1; }
 
        void push(int val)
        {
            // If top is pointing to maximum size of stack
            if (top >= MAX - 1) {
                // Stack is full
                System.out.println("Stack Overflow");
                return;
            }
 
            // Point top to new top
            top++;
 
            // Insert new element at top of stack
            stack[top] = val;
            System.out.println(
                val + " pushed into stack successfully !");
        }
    }
 
    public static void main(String[] args)
    {
        Stack st = new Stack();
        st.push(1);
        st.push(2);
    }
}
 
// This code is contributed by lokeshmvs21.


Python




# Python code to push elements in stack
class Stack:
    def __init__(self):
        self.stack = [0] * 10
        self.MAX = 10
        self.top = -1
 
    def push(self, val):
       
        # If top is pointing to maximum size of stack
        if self.top >= self.MAX - 1:
           
            # Stack is full
            print("Stack Overflow")
            return
           
        # Point top to new top
        self.top += 1
         
        # Insert new element at top of stack
        self.stack[self.top] = val
        print(str(val) + " pushed into stack successfully !\n")
 
if __name__ == "__main__":
    st = Stack()
    st.push(1)
    st.push(2)
 
# This code is contributed by adityamaharshi21


C#




// Include namespace system
using System;
 
public class GFG
{
  class Stack
  {
    public int[] stack = new int[10];
    public int MAX = 10;
    public int top;
    public void _stack()
    {
      this.top = -1;
    }
    public void push(int val)
    {
 
      // If top is pointing to maximum size of stack
      if (this.top >= this.MAX - 1)
      {
 
        // Stack is full
        Console.WriteLine("Stack Overflow");
        return;
      }
 
      // Point top to new top
      this.top++;
 
      // Insert new element at top of stack
      this.stack[this.top] = val;
      Console.WriteLine(val.ToString() + " pushed into stack successfully !");
    }
  }
  public static void Main(String[] args)
  {
    var st = new Stack();
    st.push(1);
    st.push(2);
  }
}
 
// This code is contributed by aadityaburujwale.


Javascript




// JS code for above operation
class Stack {
 
    constructor() {
        this.stack = [];
        this.MAX = 10;
        this.top = -1;
    }
 
 
    push(val) {
        // If top is pointing to
        // maximum size of stack
        if (this.top >= this.MAX - 1) {
 
            // Stack is full
            console.log("Stack Overflow");
            return;
        }
 
        // Point top to new top
        this.top++;
 
        // Insert new element at top of stack
        this.stack[this.top] = val;
        console.log(val, " pushed into stack successfully !");
    }
};
 
 
let st = new Stack();
st.push(1);
st.push(2);
 
// This code is contributed by adityamaharshi21


Output

1 pushed into stack successfully !
2 pushed into stack successfully !

Complexity Analysis:

  • Time Complexity: O(1),  In the push function a single element is inserted at the last position. This takes a single memory allocation operation which is done in constant time.
  • Auxiliary Space: O(1), As no extra space is being used.

Below is the implementation of push() using Linked List :

C++




#include <bits/stdc++.h>
using namespace std;
 
class Node {
public:
    int data;
    Node* next;
 
    Node(int val)
    {
        data = val;
        next = NULL;
    }
};
 
class Stack {
public:
    Node* top;
 
    Stack() { top = NULL; }
 
    void push(int val)
    {
        // Create new node temp and
        // allocate memory in heap
        Node* temp = new Node(val);
 
        // If stack is empty
        if (!top) {
            top = temp;
            cout << val
                 << " pushed into stack successfully !\n";
            return;
        }
 
        temp->next = top;
        top = temp;
        cout << val
             << " pushed into stack successfully !\n";
    }
};
 
int main()
{
    Stack st;
    st.push(1);
    st.push(2);
    return 0;
}


Java




/*package whatever //do not write package name here */
 
import java.io.*;
 
class GFG {
   
      static class Node{
        int data;
          Node next;
          Node(int val){
            this.data = val;
              this.next = null;
        }
    }
   
      static class Stack{
        Node top;
           
          Stack(){
            top = null;
        }
       
          void push(int val){
            // Create new node temp and allocate memory in heap
              Node temp = new Node(val);
           
              // If stack is empty
              if(top!=null){
                top = temp;
                  System.out.println(val + " pushed into stack successfully !");
                  return;
            }
               
              temp.next = top;
              top = temp;
              System.out.println(val + " pushed into stack successfully !");
        
    }
   
    public static void main (String[] args) {
         
          Stack st = new Stack();
          st.push(1);
          st.push(2);
    }
}


Python




# Python program to insert an element in a stack using linked list
class Node:
    def __init__(self, val):
        self.data = val
        self.next = None
 
class Stack:
    def __init__(self):
        self.top = None
 
    def push(self, val):
        temp = Node(val)
 
        if not self.top:
            self.top = temp
            print(val, "pushed into stack successfully!")
            return
 
        temp.next = self.top
        self.top = temp
        print(val, "pushed into stack successfully!")
 
 
st = Stack()
st.push(1)
st.push(2)
 
# This code is contributed by adityamaharshi21


C#




// C# implementation of push() using Linked List
using System;
public class GFG {
 
  class Node {
    public int data;
    public Node next;
    public Node(int val)
    {
      this.data = val;
      this.next = null;
    }
  }
 
  class Stack {
    Node top;
 
    public Stack() { top = null; }
 
    public void push(int val)
    {
 
      // Create new node temp and allocate memory in
      // heap
      Node temp = new Node(val);
 
      // If stack is empty
      if (top != null) {
        top = temp;
        Console.WriteLine(
          val
          + " pushed into stack successfully !");
        return;
      }
 
      temp.next = top;
      top = temp;
      Console.WriteLine(
        val + " pushed into stack successfully !");
    }
  }
 
  static public void Main()
  {
 
    // Code
    Stack st = new Stack();
    st.push(1);
    st.push(2);
  }
}
 
// This code is contributed by lokeshmvs21.


Javascript




// JS code for push operation using linked list
 
class Node {
 
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}
 
class Stack {
 
    constructor() {
        this.top=null;
    }
 
    push(val) {
        // Create new node temp and
        // allocate memory in heap
        let temp = new Node(val);
 
        // If stack is empty
        if (this.top==null) {
            this.top = temp;
            console.log(val, " pushed into stack successfully !");
            return;
        }
 
        temp.next = this.top;
        this.top = temp;
        console.log(val, " pushed into stack successfully !");
    }
};
 
let st = new Stack();
st.push(1);
st.push(2);
 
// This code is contributed by adityamaharshi21


Output

1 pushed into stack successfully !
2 pushed into stack successfully !

Complexity Analysis:

  • Time Complexity: O(1), Only a new node is created and the pointer of the last node is updated. This includes only memory allocation operations. Hence it can be said that insertion is done in constant time.
  • Auxiliary Space: O(1), No extra space is used.

2) pop():

This operation removes the topmost element in the stack and returns an error if the stack is already empty.

Below is the implementation of pop() using Array:

C++




#include <bits/stdc++.h>
using namespace std;
 
class Stack {
public:
    int stack[10];
    int MAX = 10;
    int top;
 
    Stack() { top = -1; }
 
    void push(int val)
    {
        // If top is pointing to maximum size of stack
        if (top >= MAX - 1) {
 
            // Stack is full
            cout << "Stack Overflow\n";
            return;
        }
 
        // Point top to new top
        top++;
 
        // Insert new element at top of stack
        stack[top] = val;
        cout << val
             << " pushed into stack successfully !\n";
    }
 
    void pop()
    {
        // Stack is already empty
        if (top < 0) {
            cout << "Stack Underflow";
        }
        else {
            // Removing top of stack
            int x = stack[top--];
            cout << "Element popped from stack : " << x
                 << "\n";
        }
    }
};
 
int main()
{
    Stack st;
    st.push(1);
 
    st.pop();
    st.pop();
    return 0;
}


Java




import java.io.*;
 
class GFG {
 
  static class Stack {
    int[] stack = new int[10];
    int MAX = 10;
    int top;
 
    Stack() { top = -1; }
 
    void push(int val)
    {
      // If top is pointing to maximum size of stack
      if (top >= MAX - 1) {
 
        // Stack is full
        System.out.println("Stack Overflow");
        return;
      }
 
      // Point top to new top
      top++;
 
      // Insert new element at top of stack
      stack[top] = val;
      System.out.println(
        val + " pushed into stack successfully !");
    }
 
    void pop()
    {
      // Stack is already empty
      if (top < 0) {
        System.out.print("Stack Underflow");
      }
      else {
        // Removing top of stack
        int x = stack[top--];
        System.out.println(
          "Element popped from stack : " + x);
      }
    }
  }
 
  public static void main(String[] args)
  {
    Stack st = new Stack();
    st.push(1);
 
    st.pop();
    st.pop();
  }
}
 
// This code is contributed by lokeshmvs21.


Python




# Python program for above approach
class Stack:
  def __init__(self):
    self.stack = [None]*10
    self.MAX = 10
    self.top = -1
 
  def push(self, val):
     
    # If top is pointing to maximum size of stack
    if self.top >= self.MAX-1:
       
      # Stack is full
      print('Stack Overflow')
      return
     
    # Point top to new top
    self.top += 1
     
    # Insert new element at top of stack
    self.stack[self.top] = val
    print(val, 'pushed into stack successfully !')
 
   # Stack is already empty
  def pop(self):
    if self.top < 0:
      print('Stack Underflow')
    else:
       
      # Removing top of stack
      x = self.stack[self.top]
      self.top -= 1
      print('Element popped from stack:', x)
 
st = Stack()
st.push(1)
st.pop()
st.pop()
 
# This code is contributed by adityamaharshi21


C#




using System;
 
public class GFG {
    class Stack {
        public int[] stack = new int[10];
        public int MAX = 10;
        public int top;
        public void _stack() { this.top = -1; }
        public void push(int val)
        {
 
            // If top is pointing to maximum size of stack
            if (this.top >= this.MAX - 1) {
 
                // Stack is full
                Console.WriteLine("Stack Overflow");
                return;
            }
 
            // Point top to new top
            this.top++;
 
            // Insert new element at top of stack
            this.stack[this.top] = val;
            Console.WriteLine(
                val.ToString()
                + " pushed into stack successfully !");
        }
        public void pop()
        {
           
            // Stack is already empty
            if (this.top <= 0) {
                Console.WriteLine("Stack Underflow");
            }
            else {
                // Removing top of stack
                int x = this.stack[this.top--];
                Console.WriteLine(
                    "Element popped from stack : "
                    + x.ToString());
            }
        }
    }
    public static void Main(String[] args)
    {
        var st = new Stack();
        st.push(1);
        st.pop();
        st.pop();
    }
}


Javascript




// JS code for pop operation using array
class Stack {
 
    constructor() {
        this.stack = [];
        this.MAX = 10;
        this.top = -1;
    }
 
 
    push(val) {
        // If top is pointing to
        // maximum size of stack
        if (this.top >= this.MAX - 1) {
 
            // Stack is full
            console.log("Stack Overflow");
            return;
        }
 
        // Point top to new top
        this.top++;
 
        // Insert new element at top of stack
        this.stack[this.top] = val;
        console.log(val, " pushed into stack successfully !");
    }
 
    pop() {
        // Stack is already empty
        if (this.top < 0) {
            console.log("Stack Underflow");
        }
        else {
            // Removing top of stack
            let x = this.stack[this.top--];
            console.log("Element popped from stack : ", x);
        }
    }
};
 
// Driver code
let st = new Stack();
st.push(1);
 
st.pop();
st.pop();
 
// This code is contributed by adityamaharshi21


Output

1 pushed into stack successfully !
Element popped from stack : 1
Stack Underflow

Complexity Analysis:

  • Time Complexity: O(1), In array implementation, only an arithmetic operation is performed i.e., the top pointer is decremented by 1. This is a constant time function.
  • Auxiliary Space: O(1), No extra space is utilized for deleting an element from the stack.

Below is the implementation of pop() using Linked List :

C++




#include <bits/stdc++.h>
using namespace std;
 
class Node {
public:
    int data;
    Node* next;
 
    Node(int val)
    {
        data = val;
        next = NULL;
    }
};
 
class Stack {
public:
    Node* top;
 
    Stack() { top = NULL; }
 
    void push(int val)
    {
        // Create new node temp and allocate memory in heap
        Node* temp = new Node(val);
 
        // If stack is empty
        if (!top) {
            top = temp;
            cout << val
                 << " pushed into stack successfully !\n";
            return;
        }
 
        temp->next = top;
        top = temp;
        cout << val
             << " pushed into stack successfully !\n";
    }
 
    void pop()
    {
        Node* temp;
 
        // Check for stack underflow
        if (top == NULL) {
            cout << "Stack Underflow\n"
                 << endl;
            return;
        }
        else {
 
            // Assign top to temp
            temp = top;
 
            cout << "Element popped from stack : "
                 << temp->data << "\n";
 
            // Assign second node to top
            top = top->next;
 
            // This will automatically destroy
            // the link between first node and second node
 
            // Release memory of top node
            // i.e delete the node
            free(temp);
        }
    }
};
 
int main()
{
    Stack st;
    st.push(1);
 
    st.pop();
    st.pop();
    return 0;
}


Java




import java.io.*;
 
class GFG {
 
    static class Node {
        int data;
        Node next;
        Node(int val)
        {
            this.data = val;
            this.next = null;
        }
    }
 
    static class Stack {
        Node top;
 
        Stack() { top = null; }
 
        void push(int val)
        {
            // Create new node temp and allocate memory in
            // heap
            Node temp = new Node(val);
 
            // If stack is empty
            if (top != null) {
                top = temp;
                System.out.println( val+" pushed into stack successfully !");
                return;
            }
 
            temp.next = top;
            top = temp;
            System.out.println(
                val + " pushed into stack successfully !");
        }
        void pop()
        {
            // Check for stack underflow
            Node temp;
           
            if (top == null) {
                System.out.println("Stack Underflow");
            }
           
            else {
                // Assign top to temp
                temp = top;
 
                System.out.println("Element popped from stack : " + temp.data);
 
                // Assign second node to top
                top = top.next;
 
                // This will automatically destroy
                // the link between first node and second
                // node
            }
        }
    }
 
    public static void main(String[] args)
    {
 
        Stack st = new Stack();
        st.push(1);
 
        st.pop();
        st.pop();
    }
}


Python




class Node:
    def __init__(self, val):
        self.data = val
        self.next = None
 
class Stack:
    def __init__(self):
        self.top = None
 
    def push(self, val):
        # Create new node temp and allocate memory in heap
        temp = Node(val)
 
        # If stack is empty
        if not self.top:
            self.top = temp
            print(val, "pushed into stack successfully !")
            return
 
        temp.next = self.top
        self.top = temp
        print(val, "pushed into stack successfully !")
 
    def pop(self):
        # Check for stack underflow
        if self.top is None:
            print("Stack Underflow")
            return
 
        # Assign top to temp
        temp = self.top
 
        print("Element popped from stack :", {temp.data})
 
        # Assign second node to top
        self.top = self.top.next
 
        # This will automatically destroy
        # the link between first node and second node
 
        # Release memory of top node
        # i.e delete the node
        del temp
 
 
st = Stack()
st.push(1)
 
st.pop()
st.pop()
 
# This code is contributed by aadityamaharshi21.


C#




using System;
 
class Node {
  public int data;
  public Node next;
 
  public Node(int val)
  {
    data = val;
    next = null;
  }
}
 
class Stack {
  public Node top;
 
  public Stack() { top = null; }
 
  public void push(int val)
  {
    // Create new node temp and allocate memory in heap
    Node temp = new Node(val);
 
    // If stack is empty
    if (top == null) {
      top = temp;
      Console.WriteLine(
        val + " pushed into stack successfully !");
      return;
    }
 
    temp.next = top;
    top = temp;
    Console.WriteLine(
      val + " pushed into stack successfully !");
  }
 
  public void pop()
  {
    Node temp;
 
    // Check for stack underflow
    if (top == null) {
      Console.WriteLine("Stack Underflow\n"
                        + "\n");
      return;
    }
    else {
 
      // Assign top to temp
      temp = top;
 
      Console.WriteLine("Element popped from stack : "
                        + temp.data + "\n");
 
      // Assign second node to top
      top = top.next;
 
      // This will automatically destroy
      // the link between first node and second node
 
      // Release memory of top node
      // i.e delete the node
      temp = null;
    }
  }
}
 
class Program {
  static void Main(string[] args)
  {
    Stack st = new Stack();
    st.push(1);
 
    st.pop();
    st.pop();
  }
}
 
// This code is contributed by adityamaharshi21.


Javascript




// JavaScript program for above approach
 
class Node {
    constructor(val) {
        this.data = val;
        this.next = null;
    }
}
 
class Stack {
    constructor() {
        this.top = null;
    }
 
    push(val) {
        // Create new node temp and allocate memory in heap
        let temp = new Node(val);
 
        // If stack is empty
        if (!this.top) {
            this.top = temp;
            console.log(val + " pushed into stack successfully !");
            return;
        }
 
        temp.next = this.top;
        this.top = temp;
        console.log(val + " pushed into stack successfully !");
    }
 
    pop() {
        let temp;
 
        // Check for stack underflow
        if (this.top == null) {
            console.log("Stack Underflow");
            return;
        } else {
            // Assign top to temp
            temp = this.top;
 
            console.log("Element popped from stack : " + temp.data);
 
            // Assign second node to top
            this.top = this.top.next;
 
            // This will automatically destroy
            // the link between first node and second node
 
            // Release memory of top node
            // i.e delete the node
            temp = null;
        }
    }
}
 
let st = new Stack();
st.push(1);
 
st.pop();
st.pop();
 
// This code is contributed by adityamaharshi21


Output

1 pushed into stack successfully !
Element popped from stack : 1
Stack Underflow

Complexity Analysis:

  • Time Complexity: O(1), Only the first node is deleted and the top pointer is updated. This is a constant time operation.
  • Auxiliary Space: O(1). No extra space is utilized for deleting an element from the stack.

3) peek():

This operation prints the topmost element of the stack.

Below is the Implementation of peek() using Array:

C++




#include <bits/stdc++.h>
using namespace std;
 
class Stack {
public:
    int stack[10];
    int MAX = 10;
    int top;
 
    Stack() { top = -1; }
 
    void push(int val)
    {
        // If top is pointing to maximum size of stack
        if (top >= MAX - 1) {
 
            // Stack is full
            cout << "Stack Overflow\n";
            return;
        }
 
        // Point top to new top
        top++;
 
        // Insert new element at top of stack
        stack[top] = val;
        cout << val
             << " pushed into stack successfully !\n";
    }
 
    int peek()
    {
        // Stack is already empty then
        // we can't get peek element
        if (top < 0) {
            cout << "Stack is Empty\n";
            return 0;
        }
        else {
 
            // Retrieving top element from stack
            int x = stack[top];
            return x;
        }
    }
};
 
int main()
{
    Stack st;
    st.push(1);
    st.push(2);
 
    cout << "Peek element of stack : "
         << st.peek() << "\n";
    return 0;
}


Java




/*package whatever //do not write package name here */
import java.io.*;
 
class GFG {
 
  static class Stack {
    int[] stack = new int[10];
    int MAX = 10;
    int top;
 
    Stack() { top = -1; }
 
    void push(int val)
    {
      // If top is pointing to maximum size of stack
      if (top >= MAX - 1) {
 
        // Stack is full
        System.out.println("Stack Overflow");
        return;
      }
 
      // Point top to new top
      top++;
 
      // Insert new element at top of stack
      stack[top] = val;
      System.out.println(
        val + " pushed into stack successfully !");
    }
 
    int peek()
    {
      // Stack is already empty then
      // we can't get peek element
      if (top < 0) {
        System.out.println("Stack is Empty\n");
        return 0;
      }
      else {
 
        // Retrieving top element from stack
        int x = stack[top];
        return x;
      }
    }
  }
 
  public static void main (String[] args) {
 
    Stack st = new Stack();
    st.push(1);
    st.push(2);
 
    System.out.println("Peek element of stack : "
                       + st.peek() + "\n");
 
  }
}
 
// This code is contributed by akashish__


Python




class Stack:
    def __init__(self):
        self.stack = [0] * 10
        self.MAX = 10
        self.top = -1
 
    def push(self, val):
        # If top is pointing to maximum size of stack
        if self.top >= self.MAX - 1:
            # Stack is full
            print("Stack Overflow")
            return
 
        # Point top to new top
        self.top += 1
 
        # Insert new element at top of stack
        self.stack[self.top] = val
        print(val, " pushed into stack successfully !")
 
    def peek(self):
        # Stack is already empty then
        # we can't get peek element
        if self.top < 0:
            print("Stack is Empty")
            return 0
        else:
            # Retrieving top element from stack
            x = self.stack[self.top]
            return x
 
def main():
    st = Stack()
    st.push(1)
    st.push(2)
 
    print("Peek element of stack : ", st.peek())
    return 0
 
if __name__ == "__main__":
    main()
 
    # This code is contributed by adityamaharshi21.


C#




// C# program for peek operation in Stack
using System;
 
public class GFG {
  class Stack {
    public int[] stack = new int[10];
    public int MAX = 10;
    public int top;
    public void _stack() { this.top = -1; }
    public void push(int val)
    {
 
      // If top is pointing to maximum size of stack
      if (this.top >= this.MAX - 1) {
 
        // Stack is full
        Console.WriteLine("Stack Overflow");
        return;
      }
 
      // Point top to new top
      this.top++;
 
      // Insert new element at top of stack
      this.stack[this.top] = val;
      Console.WriteLine(
        val.ToString()
        + " pushed into stack successfully !\n");
    }
    public int peek()
    {
      // Stack is already empty then
      // we can't get peek element
      if (this.top < 0) {
        Console.WriteLine("Stack is Empty");
        return 0;
      }
      else {
 
        // Retrieving top element from stack
        int x = stack[this.top];
        return x;
      }
    }
  }
  public static void Main(String[] args)
  {
    var st = new Stack();
    st.push(1);
    st.push(2);
    Console.WriteLine("Peek element of stack : "
                      + st.peek());
  }
}
 
// This code is contributed by adityamaharshi21.


Javascript




// JS code for above approach
 
class Stack {
    constructor() {
        this.stack = [];
        this.MAX = 10;
        this.top = -1;
    }
 
    Stack() { top = -1; }
 
    push(val) {
        // If top is pointing to
        // maximum size of stack
        if (this.top >= this.MAX - 1) {
 
            // Stack is full
            console.log("Stack Overflow");
            return;
        }
 
        // Point top to new top
        this.top++;
 
        // Insert new element at top of stack
        this.stack[this.top] = val;
        console.log(val, " pushed into stack successfully !");
    }
 
    peek() {
        // Stack is already empty then
        // we can't get peek element
        if (this.top < 0) {
            console.log("Stack is Empty");
            return 0;
        }
        else {
 
            // Retrieving top element from stack
            let x = this.stack[this.top];
            return x;
        }
    }
};
 
let st = new Stack;
st.push(1);
st.push(2);
 
console.log("Peek element of stack : ", st.peek())
 
return 0;
 
// This code is contributed by adityamaharshi21


Output

1 pushed into stack successfully !
2 pushed into stack successfully !
Peek element of stack : 2

Complexity Analysis:

  • Time Complexity: O(1), Only a memory address is accessed. This is a constant time operation.
  • Auxiliary Space: O(1), No extra space is utilized to access the value.

Below is the implementation of peek() using Linked List :

C++




#include <bits/stdc++.h>
using namespace std;
 
class Node {
public:
    int data;
    Node* next;
 
    Node(int val)
    {
        data = val;
        next = NULL;
    }
};
 
class Stack {
public:
    Node* top;
 
    Stack() { top = NULL; }
 
    void push(int val)
    {
        // Create new node temp and
        // allocate memory in heap
        Node* temp = new Node(val);
 
        // If stack is empty
        if (!top) {
            top = temp;
            cout << val
                 << " pushed into stack successfully !\n";
            return;
        }
 
        temp->next = top;
        top = temp;
        cout << val
             << " pushed into stack successfully !\n";
    }
 
    bool isEmpty()
    {
        // If top is NULL it means that
        // there are no elements are in stack
        return top == NULL;
    }
 
    int peek()
    {
        // If stack is not empty,
        // return the top element
        if (!isEmpty())
            return top->data;
        else
            cout << "Stack is Empty\n";
        exit(1);
    }
};
 
int main()
{
    Stack st;
    st.push(1);
    cout << "Peek element of stack : "
         << st.peek() << "\n";
    return 0;
}


Java




import java.util.Scanner;
 
class Node {
    public int data;
    public Node next;
 
    public Node(int val)
    {
        data = val;
        next = null;
    }
}
 
class Stack {
    public Node top;
 
    public Stack() { top = null; }
 
    public void push(int val)
    {
        // Create new node temp and
        // allocate memory in heap
        Node temp = new Node(val);
 
        // If stack is empty
        if (top == null) {
            top = temp;
            System.out.println(
                val + " pushed into stack successfully!");
            return;
        }
 
        temp.next = top;
        top = temp;
        System.out.println(
            val + " pushed into stack successfully!");
    }
 
    public boolean isEmpty()
    {
        // If top is null it means that
        // there are no elements are in stack
        return top == null;
    }
 
    public int peek()
    {
        // If stack is not empty,
        // return the top element
        if (!isEmpty()) {
            return top.data;
        }
        else {
            System.out.println("Stack is Empty");
            System.exit(1);
        }
        return 0;
    }
}
 
public class Main {
    public static void main(String[] args)
    {
        Stack st = new Stack();
        st.push(1);
        System.out.println("Peek element of stack: "
                           + st.peek());
    }
}


Python




class Node:
    def __init__(self, val):
        self.data = val
        self.next = None
 
class Stack:
    def __init__(self):
        self.top = None
 
    def push(self, val):
        temp = Node(val)
        if self.top is None:
            self.top = temp
            print(val,"pushed into stack successfully !")
            return
        temp.next = self.top
        self.top = temp
        print(val," pushed into stack successfully !")
 
    def is_empty(self):
        return self.top is None
 
    def peek(self):
        if not self.is_empty():
            return self.top.data
        else:
            print("Stack is Empty")
            exit(1)
 
st = Stack()
st.push(1)
print("Peek element of stack:",st.peek())


Javascript




class Node {
  constructor(val) {
    this.data = val;
    this.next = null;
  }
}
 
class Stack {
  constructor() {
    this.top = null;
  }
 
  push(val) {
    let temp = new Node(val);
    if (this.top === null) {
      this.top = temp;
      console.log(val + " pushed into stack successfully !");
      return;
    }
    temp.next = this.top;
    this.top = temp;
    console.log(val + " pushed into stack successfully !");
  }
 
  isEmpty() {
    return this.top === null;
  }
 
  peek() {
    if (!this.isEmpty()) {
      return this.top.data;
    }
    else {
      console.log("Stack is Empty");
      process.exit(1);
    }
  }
}
 
const st = new Stack();
st.push(1);
console.log("Peek element of stack:", st.peek());


C#




using System;
 
class Node {
    public int data;
    public Node next;
 
    public Node(int val)
    {
        data = val;
        next = null;
    }
}
 
class Stack {
    public Node top;
 
    public Stack() { top = null; }
 
    public void push(int val)
    {
        // Create new node temp and
        // allocate memory in heap
        Node temp = new Node(val);
 
        // If stack is empty
        if (top == null) {
            top = temp;
            Console.WriteLine(val + " pushed into stack successfully !");
            return;
        }
 
        temp.next = top;
        top = temp;
        Console.WriteLine(val + " pushed into stack successfully !");
    }
 
    public bool isEmpty()
    {
        // If top is NULL it means that
        // there are no elements are in stack
        return top == null;
    }
 
    public int peek()
    {
        // If stack is not empty,
        // return the top element
        if (!isEmpty())
            return top.data;
        else
            Console.WriteLine("Stack is Empty");
        Environment.Exit(1);
        return -1; // this line will never be reached
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        Stack st = new Stack();
        st.push(1);
        Console.WriteLine("Peek element of stack: " + st.peek() + "\n");
    }
}


Output

1 pushed into stack successfully !
Peek element of stack : 1

Complexity Analysis:

  • Time Complexity: O(1). In linked list implementation also a single memory address is accessed. It takes constant time.
  • Auxiliary Space: O(1). No extra space is utilized to access the element because only the value in the node at the top pointer is read.

4) isempty():

This operation tells us whether the stack is empty or not.

Below is the implementation of isempty() using Array :

C++




#include <bits/stdc++.h>
using namespace std;
 
class Stack {
public:
    int stack[10];
    int MAX = 10;
    int top;
 
    Stack() { top = -1; }
 
    void push(int val)
    {
        // If top is pointing to
        // maximum size of stack
        if (top >= MAX - 1) {
 
            // Stack is full
            cout << "Stack Overflow\n";
            return;
        }
 
        // Point top to new top
        top++;
 
        // Insert new element at top of stack
        stack[top] = val;
        cout << val
             << " pushed into stack successfully !\n";
    }
 
    bool isEmpty()
    {
        // If stack is empty return 1
        return (top < 0);
    }
};
 
int main()
{
    Stack st;
    cout << st.isEmpty();
 
    return 0;
}


Java




// Java code for above approach
 
import java.io.*;
 
class GFG {
 
  static class Stack {
    int stack[] = new int[10];
    int MAX = 10;
    int top;
 
    void stack() { top = -1; }
 
    void push(int val)
    {
      // If top is pointing to maximum size of stack
      if (top >= MAX - 1) {
        // Stack is full
        System.out.println("Stack Overflow");
        return;
      }
 
      // Point top to new top
      top++;
 
      // Insert new element at top of stack
      stack[top] = val;
      System.out.println(
        val + " pushed into stack successfully !");
    }
    boolean isEmpty(){
      return (top<=0);
    }
  }
 
  public static void main(String[] args)
  {
    Stack st = new Stack();
    System.out.println(st.isEmpty());
  }
}
 
// This code is contributed by adityamaharshi21.


Javascript




// JS code for above operation
 
class Stack {
 
 
    constructor() {
        this.stack = [];
        this.MAX = 10;
        this.top = -1;
    }
 
 
    push(val) {
        // If top is pointing to
        // maximum size of stack
        if (this.top >= this.MAX - 1) {
 
            // Stack is full
            console.log("Stack Overflow");
            return;
        }
 
        // Point top to new top
        this.top++;
 
        // Insert new element at top of stack
        this.stack[this.top] = val;
        console.log(val, " pushed into stack successfully !");
    }
 
    isEmpty() {
        // If stack is empty return 1
        return (this.top < 0);
    }
};
 
// Driver code
let st = new Stack();
console.log(st.isEmpty());
 
// This code is contributed by adityamaharshi21


Python




class Stack:
    def __init__(self):
        self.stack = [0]*10
        self.MAX = 10
        self.top = -1
     
    def push(self, val):
        if self.top >= self.MAX - 1:
            print("Stack Overflow")
            return
        self.top += 1
        self.stack[self.top] = val
        print(val, "pushed into stack successfully!")
     
    def isEmpty(self):
        return (self.top < 0)
 
st = Stack()
print(st.isEmpty())


Output

1

Complexity Analysis:

  • Time Complexity: O(1), It only performs an arithmetic operation to check if the stack is empty or not.
  • Auxiliary Space: O(1), It requires no extra space.

Below is the implementation of isempty() using Linked List :

C++




#include <bits/stdc++.h>
using namespace std;
 
class Node {
public:
    int data;
    Node* next;
 
    Node(int val)
    {
        data = val;
        next = NULL;
    }
};
 
class Stack {
public:
    Node* top;
 
    Stack() { top = NULL; }
 
    void push(int val)
    {
        // Create new node temp and allocate memory in heap
        Node* temp = new Node(val);
 
        // If stack is empty
        if (!top) {
            top = temp;
            cout << val
                 << " pushed into stack successfully !\n";
            return;
        }
 
        temp->next = top;
        top = temp;
        cout << val
             << " pushed into stack successfully !\n";
    }
 
    bool isEmpty()
    {
        // If top is NULL it means that
        // there are no elements are in stack
        return top == NULL;
    }
};
 
int main()
{
    Stack st;
 
    cout << st.isEmpty();
    return 0;
}


Output

1

Complexity Analysis:

  • Time Complexity: O(1), It checks if the pointer of the top pointer is Null or not. This operation takes constant time.
  • Auxiliary Space: O(1), No extra space is required.

5) size():

This operation returns the current size of the stack.

Below is the implementation of size() using Array:

C++




#include <bits/stdc++.h>
using namespace std;
 
class Stack {
public:
    int stack[10];
    int MAX = 10;
    int top;
 
    Stack() { top = -1; }
 
    void push(int val)
    {
        // If top is pointing to maximum size of stack
        if (top >= MAX - 1) {
 
            // Stack is full
            cout << "Stack Overflow\n";
            return;
        }
 
        // Point top to new top
        top++;
 
        // Insert new element at top of stack
        stack[top] = val;
        cout << val
             << " pushed into stack successfully !\n";
    }
    int size() { return top + 1; }
};
 
int main()
{
    Stack st;
    st.push(1);
    st.push(2);
 
    cout << "The size of the stack is " << st.size()
         << endl;
    return 0;
}


Javascript




// JS code for above operation
 
class Stack {
    constructor() {
        this.stack = [];
        this.MAX = 10;
        this.top = -1;
    }
 
    push(val) {
        // If top is pointing to maximum size of stack
        if (this.top >= this.MAX - 1) {
 
            // Stack is full
            console.log("Stack Overflow");
            return;
        }
 
        // Point top to new top
        this.top++;
 
        // Insert new element at top of stack
        this.stack[this.top] = val;
        console.log(val, " pushed into stack successfully !");
    }
    size() { return this.top + 1; }
};
 
let st = new Stack;
st.push(1);
st.push(2);
 
console.log("The size of the stack is ", st.size());
return 0;
 
// This code is contributed by adityamaharshi21


Output

1 pushed into stack successfully !
2 pushed into stack successfully !
The size of the stack is 2

Complexity Analysis:

  • Time Complexity: O(1), because this operation just performs a basic arithmetic operation.
  • Auxiliary Space: O(1) NO extra space is required to calculate the value of the top pointer.

Below is the implementation of size() using Linked List:

C++




#include <bits/stdc++.h>
using namespace std;
 
class Node {
public:
    int data;
    Node* next;
 
    Node(int val)
    {
        data = val;
        next = NULL;
    }
};
 
class Stack {
public:
    Node* top;
    Node* head;
    int sizeOfStack;
    Stack()
    {
        head = NULL;
        top = NULL;
        sizeOfStack = 0;
    }
 
    void push(int val)
    {
        // Create new node temp and
        // allocate memory in heap
        Node* temp = new Node(val);
        sizeOfStack += 1;
 
        // If stack is empty
        if (!top) {
            top = temp;
            return;
        }
 
        temp->next = top;
        top = temp;
    }
 
    int size() { return sizeOfStack; }
};
 
int main()
{
    Stack st;
    st.push(1);
    st.push(3);
    st.push(4);
 
    cout << "Size of stack : " << st.size();
    return 0;
}


Output

Size of stack : 3

Complexity Analysis:

  • Time Complexity: O(1), because the size is calculated and updated every time a push or pop operation is performed and is just returned in this function.
  • Auxiliary Space: O(1), NO extra space is required to calculate the size of the stack.

My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!