Design and Implement Special Stack Data Structure

Introduction

A basic data structure in software engineering and computer science is the stack. The last piece added to the stack is the first one withdrawn, according to the Last-In-First-Out (LIFO) principle, which is followed by a stack, which is a linear data structure. Even while push, pop, and peek are a stack's three basic actions, there are situations when you need the more specialized capability to tackle particular challenges effectively. This article will examine the idea of a "special stack" and go into its creation and application, concentrating on a popular special stack called a "Min Stack."

Fundamentals of a Stack

Let's quickly review the essential features and functions of a conventional stack before getting into custom stacks:

Push: Pushing something up to the top of the stack adds it.
Pop: The top element in the stack is eliminated with this action.
Peek (or Top): This function lets you see what's at the top without taking it off.

Stacks are employed in many different methods, including expression parsing, keeping track of function calls (the call stack), and problem-solving where a last-in-first-out order is crucial.

Special Stacks

A special stack is a variant of the ordinary stack data structure that goes beyond the fundamental operations to allow for extra operations or to enforce particular limitations. The Min Stack, which makes it possible to quickly determine the lowest element in the stack at any given time, is one of the most widely used special stacks.

Design of a Min Stack

Data Structures

Two primary data structures are required to implement a Min Stack:

Main Stack: The primary items are kept in the main stack. This stack is used for the common stack operations (push, pop, and peek).
Auxiliary Stack: The purpose of the auxiliary stack is to maintain track of the main stack's minimal items. The auxiliary stack will always hold the current minimum element and will always be the same size as the main stack.

Functions

Push

The following actions are taken when adding a new element to the stack:

To the main stack, add the element.
Verify whether the element is less than or equal to the top element of the auxiliary stack, which is the current minimum.
Should it be, additionally place the element on the auxiliary stack.

Pop

Pop To remove an element from the stack, take the following actions:

Remove the component from the primary stack.
Verify whether the part was the bare minimum. Pop the top element from the auxiliary stack as well if that's the case.

Peek (Top)

This action retrieves the top element from the main stack and stays the same.

Get Minimum

This action takes the auxiliary stack's minimum element and obtains it. Without having to look through the full stack, it enables you to locate the least element in the main stack quickly.

Code

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#define MAX_SIZE 100
typedef struct {
    int items[MAX_SIZE];
    int top;
} Stack;
typedef struct {
    Stack main_stack;
    Stack min_stack;
} 
SpecialStack;
void initialize(Stack* stack) {
    stack->top = -1;
}
int isEmpty(Stack* stack) {
    return stack->top == -1;
}
int isFull(Stack* stack) {
    return stack->top == MAX_SIZE - 1;
}
void push(Stack* stack, int value) {
    if (isFull(stack)) {
        printf("Stack overflow!\n");
        return;
    }
    stack->items[++stack->top] = value;
}
int pop(Stack* stack) {
    if (isEmpty(stack)) {
        printf("Stack underflow!\n");
        return INT_MIN;
    }
    return stack->items[stack->top--];
}
int top(Stack* stack) {
    if (isEmpty(stack)) {
        printf("Stack is empty!\n");
        return INT_MIN;
    }
    return stack->items[stack->top];
}
void initializeSpecialStack(SpecialStack* specialStack) {
    initialize(&specialStack->main_stack);
    initialize(&specialStack->min_stack);
}
void pushSpecial(SpecialStack* specialStack, int value) {
    push(&specialStack->main_stack, value);
    if (isEmpty(&specialStack->min_stack) || value <= top(&specialStack->min_stack)) 
{
        push(&specialStack->min_stack, value);
    }
}
int popSpecial(SpecialStack* specialStack) {
    if (isEmpty(&specialStack->main_stack)) {
        printf("SpecialStack is empty!\n");
        return INT_MIN;
    }
    int poppedValue = pop(&specialStack->main_stack);
    if (poppedValue == top(&specialStack->min_stack)) {
        pop(&specialStack->min_stack);
    }
    return poppedValue;
}
int getMin(SpecialStack* specialStack) {
    if (isEmpty(&specialStack->min_stack)) {
        printf("SpecialStack is empty!\n");
        return INT_MIN;
    }
    return top(&specialStack->min_stack);
}
int main() {
    SpecialStack specialStack;
    initializeSpecialStack(&specialStack);
    printf("Pushing elements onto the SpecialStack...\n");
    pushSpecial(&specialStack, 3);
    pushSpecial(&specialStack, 5);
    pushSpecial(&specialStack, 2);
    pushSpecial(&specialStack, 7);
    pushSpecial(&specialStack, 1);
    printf("Current SpecialStack:\n");
    printf("Top Element: %d\n", top(&specialStack.main_stack));
    printf("Minimum Element: %d\n", getMin(&specialStack));
    printf("Popping elements from the SpecialStack...\n");
    popSpecial(&specialStack);
    printf("After Popping:\n");
    printf("Top Element: %d\n", top(&specialStack.main_stack));
    printf("Minimum Element: %d\n", getMin(&specialStack));
    return 0;
}

Output:

Design and Implement Special Stack Data Structure

Advantages

Efficient Minimum Retrieval: Finding the minimum element in constant time (O(1)) is the primary benefit. This is essential for resolving specific issues when you must effectively track the lowest value in a stack.
Maintaining Order: A Min Stack is appropriate for applications that need access to minimum values as well as ordered processing since it preserves the order of elements while monitoring minimum values.
Space Efficiency: The space complexity of a Min Stack is not greatly increased, even though it tracks minimums using an auxiliary stack. The area above is a little small.

Next TopicEnhancing Password Strength

← prev next →