Check whether the given string is Palindrome using Stack

Given a string s, the task is to determine whether the given string is a palindrome or not by utilizing a stack. A palindrome is a string that reads the same forwards and backwards.

Examples:

Input: s = "geeksforgeeks"
Output: No
Explanation: Reversing "geeksforgeeks" using a stack results in "skeegrofskeeg", which is not the same as the original string. Hence, it is not a palindrome.

Input: s = "madam"
Output: Yes
Explanation: Reversing "madam" using a stack gives the same string, so it is a palindrome.

Input: s = "hello"
Output: No
Explanation: Reversing "hello" gives "olleh", which is different, so it is not a palindrome.

Add Entire String to Stack and Check - O(n) Time and O(n) Space

The idea is to use a stack to reverse the string by pushing each character, then comparing it with the original. Since a stack follows Last-In-First-Out, popping elements gives the reverse of the string. If all characters match during this comparison, the string is a palindrome, else it is not. This approach directly uses the stack's reversing nature to validate symmetry.

• Create an empty stack to hold characters from the input string.
• Traverse the string from left to right and push each character onto the stack.
• Begin a second traversal of the string from the start again.
• For every character, compare it with the top element of the stack.
• If any character does not match, return false as it cannot be a palindrome.
• If all characters match during comparison this means its a palindrome, return true after emptying the stack.

// C++ program to check if a string 
// is a palindrome using a stack
#include <iostream>
#include <stack>
using namespace std;

// Function to check if the string 
// is a palindrome
bool isPalindrome(string s) {

    stack<char> stk;

    // Push all characters onto the stack
    for (int i = 0; i < s.length(); i++) {
        stk.push(s[i]);
    }

    // Compare characters while popping 
    // from the stack
    for (int i = 0; i < s.length(); i++) {
        if (s[i] != stk.top()) {
            return false;
        }
        stk.pop();
    }

    return true;
}

// Driver code
int main() {

    string s = "geeksforgeeks";

    if (isPalindrome(s)) {
        cout << "Yes" << endl;
    } else {
        cout << "No" << endl;
    }

    return 0;
}

// C program to check if a string 
// is a palindrome using a stack
#include <stdio.h>
#include <string.h>

// Function to check if the string 
// is a palindrome
int isPalindrome(char s[]) {

    int len = strlen(s);
    int top = -1;
    
    char stk[len];

    // Push all characters onto the stack
    for (int i = 0; i < len; i++) {
        stk[++top] = s[i];
    }

    // Compare characters while popping 
    // from the stack
    for (int i = 0; i < len; i++) {
        if (s[i] != stk[top--]) {
            return 0;
        }
    }

    return 1;
}

// Driver code
int main() {

    char s[] = "geeksforgeeks";

    if (isPalindrome(s)) {
        printf("Yes\n");
    } else {
        printf("No\n");
    }

    return 0;
}

// Java program to check if a string 
// is a palindrome using a stack
import java.util.Stack;

class GfG {

    // Function to check if the string 
    // is a palindrome
    static boolean isPalindrome(String s) {

        Stack<Character> stk = new Stack<>();

        // Push all characters onto the stack
        for (int i = 0; i < s.length(); i++) {
            stk.push(s.charAt(i));
        }

        // Compare characters while popping 
        // from the stack
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) != stk.pop()) {
                return false;
            }
        }

        return true;
    }

    // Driver code
    public static void main(String[] args) {

        String s = "geeksforgeeks";

        if (isPalindrome(s)) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }
    }
}

# Python program to check if a string 
# is a palindrome using a stack

# Function to check if the string 
# is a palindrome
def isPalindrome(s):

    stk = []

    # Push all characters onto the stack
    for i in range(len(s)):
        stk.append(s[i])

    # Compare characters while popping 
    # from the stack
    for i in range(len(s)):
        if s[i] != stk.pop():
            return False

    return True

# Driver code
if __name__ == "__main__":

    s = "geeksforgeeks"

    if isPalindrome(s):
        print("Yes")
    else:
        print("No")

// C# program to check if a string 
// is a palindrome using a stack
using System;
using System.Collections.Generic;

class GfG {

    // Function to check if the string 
    // is a palindrome
    public static bool isPalindrome(string s) {

        Stack<char> stk = new Stack<char>();

        // Push all characters onto the stack
        for (int i = 0; i < s.Length; i++) {
            stk.Push(s[i]);
        }

        // Compare characters while popping 
        // from the stack
        for (int i = 0; i < s.Length; i++) {
            if (s[i] != stk.Pop()) {
                return false;
            }
        }

        return true;
    }

    // Driver code
    public static void Main() {

        string s = "geeksforgeeks";

        if (isPalindrome(s)) {
            Console.WriteLine("Yes");
        } else {
            Console.WriteLine("No");
        }
    }
}

// JavaScript program to check if a string 
// is a palindrome using a stack

// Function to check if the string 
// is a palindrome
function isPalindrome(s) {

    let stk = [];

    // Push all characters onto the stack
    for (let i = 0; i < s.length; i++) {
        stk.push(s[i]);
    }

    // Compare characters while popping 
    // from the stack
    for (let i = 0; i < s.length; i++) {
        if (s[i] !== stk.pop()) {
            return false;
        }
    }

    return true;
}

// Driver code
let s = "geeksforgeeks";

if (isPalindrome(s)) {
    console.log("Yes");
} else {
    console.log("No");
}

No

Time Complexity: O(n), Each character is processed twice: once pushed, once compared.
Space Complexity: O(n), Stack stores all characters of the input string.

Add Only Half of the String to Stack - O(n) Time and O(n) Space

In the previous approach, we stored the entire string in the stack, which used O(n) space. The observation here is that to compare the two halves, only the first half needs to be stored. By skipping the middle character in case of odd lengths, we compare the second half directly with the stack contents.

// C++ program to check if a string 
// is a palindrome using a stack 
#include <iostream>
#include <stack>
using namespace std;

// Function to check if the string 
// is a palindrome
bool isPalindrome(string s) {

    stack<char> stk;
    int n = s.length();
    int mid = n / 2;

    // Push the first half characters 
    // onto the stack
    for (int i = 0; i < mid; i++) {
        stk.push(s[i]);
    }

    // If the string length is odd, 
    // skip the middle character
    if (n % 2 != 0) {
        mid++;
    }

    // Compare the second half characters
    // with those in the stack
    for (int i = mid; i < n; i++) {
        if (s[i] != stk.top()) {
            return false;
        }
        stk.pop();
    }

    // If all characters matched, 
    // the string is a palindrome
    return true;
}

// Driver code
int main() {

    string s = "geeksforgeeks";

    if (isPalindrome(s)) {
        cout << "Yes" << endl;
    } else {
        cout << "No" << endl;
    }

    return 0;
}

// C program to check if a string 
// is a palindrome using a stack
#include <stdio.h>
#include <string.h>

// Function to check if the string 
// is a palindrome
int isPalindrome(char s[]) {

    int len = strlen(s);
    int mid = len / 2;
    int top = -1;

    char stk[mid];

    // Push first half characters onto the stack
    for (int i = 0; i < mid; i++) {
        stk[++top] = s[i];
    }

    // If the string length is odd,
    // skip the middle character
    if (len % 2 != 0) {
        mid++;
    }

    // Compare characters while popping 
    // from the stack
    for (int i = mid; i < len; i++) {
        if (s[i] != stk[top--]) {
            return 0;
        }
    }

    return 1;
}

// Driver code
int main() {

    char s[] = "geeksforgeeks";

    if (isPalindrome(s)) {
        printf("Yes\n");
    } else {
        printf("No\n");
    }

    return 0;
}

// Java program to check if a string 
// is a palindrome using a stack 
import java.util.*;

class GfG {

    // Function to check if the string 
    // is a palindrome
    public static boolean isPalindrome(String s) {

        Stack<Character> stk = new Stack<>();
        int n = s.length();
        int mid = n / 2;

        // Push the first half characters 
        // onto the stack
        for (int i = 0; i < mid; i++) {
            stk.push(s.charAt(i));
        }

        // If the string length is odd, 
        // skip the middle character
        if (n % 2 != 0) {
            mid++;
        }

        // Compare the second half characters
        // with those in the stack
        for (int i = mid; i < n; i++) {
            if (s.charAt(i) != stk.peek()) {
                return false;
            }
            stk.pop();
        }

        // If all characters matched, 
        // the string is a palindrome
        return true;
    }

    // Driver code
    public static void main(String[] args) {

        String s = "geeksforgeeks";

        if (isPalindrome(s)) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }
    }
}

# Python program to check if a string 
# is a palindrome using a stack 

def isPalindrome(s):

    stk = []
    n = len(s)
    mid = n // 2

    # Push the first half characters 
    # onto the stack
    for i in range(mid):
        stk.append(s[i])

    # If the string length is odd, 
    # skip the middle character
    if n % 2 != 0:
        mid += 1

    # Compare the second half characters
    # with those in the stack
    for i in range(mid, n):
        if s[i] != stk[-1]:
            return False
        stk.pop()

    # If all characters matched, 
    # the string is a palindrome
    return True

# Driver code
if __name__ == "__main__":

    s = "geeksforgeeks"

    if isPalindrome(s):
        print("Yes")
    else:
        print("No")

// C# program to check if a string 
// is a palindrome using a stack 
using System;
using System.Collections.Generic;

class GfG {

    // Function to check if the string 
    // is a palindrome
    public static bool isPalindrome(string s) {

        Stack<char> stk = new Stack<char>();
        int n = s.Length;
        int mid = n / 2;

        // Push the first half characters 
        // onto the stack
        for (int i = 0; i < mid; i++) {
            stk.Push(s[i]);
        }

        // If the string length is odd, 
        // skip the middle character
        if (n % 2 != 0) {
            mid++;
        }

        // Compare the second half characters
        // with those in the stack
        for (int i = mid; i < n; i++) {
            if (s[i] != stk.Peek()) {
                return false;
            }
            stk.Pop();
        }

        // If all characters matched, 
        // the string is a palindrome
        return true;
    }

    // Driver code
    public static void Main() {

        string s = "geeksforgeeks";

        if (isPalindrome(s)) {
            Console.WriteLine("Yes");
        } else {
            Console.WriteLine("No");
        }
    }
}

// JavaScript program to check if a string 
// is a palindrome using a stack 

function isPalindrome(s) {

    let stk = [];
    let n = s.length;
    let mid = Math.floor(n / 2);

    // Push the first half characters 
    // onto the stack
    for (let i = 0; i < mid; i++) {
        stk.push(s[i]);
    }

    // If the string length is odd, 
    // skip the middle character
    if (n % 2 !== 0) {
        mid++;
    }

    // Compare the second half characters
    // with those in the stack
    for (let i = mid; i < n; i++) {
        if (s[i] !== stk[stk.length - 1]) {
            return false;
        }
        stk.pop();
    }

    // If all characters matched, 
    // the string is a palindrome
    return true;
}

// Driver code
let s = "geeksforgeeks";

if (isPalindrome(s)) {
    console.log("Yes");
} else {
    console.log("No");
}

Time Complexity: O(n), Each character is visited once for push and pop.
Space Complexity: O(n/2), Only half of the characters are stored in the stack.