Largest Rectangular Area in a Histogram

#include <stdio.h>

int getMaxArea(int arr[],int n) {
    int res = 0;

    // Consider every bar one by one
    for (int i = 0; i < n; i++) {
        int curr = arr[i];

        // Traverse left while we have a greater height bar
        for (int j = i - 1; j >= 0 && arr[j] >= arr[i]; j--) {
            curr += arr[i];
        }

        // Traverse right while we have a greater height bar
        for (int j = i + 1; j < n && arr[j] >= arr[i]; j++) {
            curr += arr[i];
        }

        if (curr > res) {
            res = curr;
        }
    }

    return res;
}

int main() {
    int arr[] = {60, 20, 50, 40, 10, 50, 60};
     int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d\n", getMaxArea(arr,n));
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

// Stack structure
struct Stack {
    int top;
    int capacity;
    int* items;
};

// Function to create an empty stack with dynamic memory allocation
struct Stack* createStack(int capacity) {
    struct Stack* stack = 
                (struct Stack*)malloc(sizeof(struct Stack));
    stack->capacity = capacity;
    stack->top = -1;
    stack->items = (int*)malloc(stack->capacity * sizeof(int));
    return stack;
}

// Function to check if the stack is empty
int isEmpty(struct Stack* stack) {
    return stack->top == -1;
}

// Function to push an element onto the stack
void push(struct Stack* stack, int value) {
    if (stack->top == stack->capacity - 1) {
        printf("Stack overflow\n");
        return;
    }
    stack->items[++(stack->top)] = value;
}

// Function to pop an element from the stack
int pop(struct Stack* stack) {
    if (isEmpty(stack)) {
        printf("Stack underflow\n");
        return -1;
    }
    return stack->items[(stack->top)--];
}

// Function to get the top element of the stack
int peek(struct Stack* stack) {
    if (!isEmpty(stack)) {
        return stack->items[stack->top];
    }
    return -1;
}

// Function to find the next smaller element for every element
void nextSmaller(int arr[], int n, int nextS[]) {
    struct Stack* stack = createStack(n);

    // Initialize with n for the cases
    // when next smaller does not exist
    for (int i = 0; i < n; i++) {
        nextS[i] = n;
    }

    // Traverse all array elements from left to right
    for (int i = 0; i < n; i++) {
        while (!isEmpty(stack) && arr[i] < arr[peek(stack)]) {
            nextS[peek(stack)] = i;
            pop(stack);
        }
        push(stack, i);
    }
}

// Function to find the previous smaller element for every element
void prevSmaller(int arr[], int n, int prevS[]) {
    struct Stack* stack = createStack(n);

    // Initialize with -1 for the cases when prev smaller does not exist
    for (int i = 0; i < n; i++) {
        prevS[i] = -1;
    }

    // Traverse all array elements from left to right
    for (int i = 0; i < n; i++) {
        while (!isEmpty(stack) && arr[i] < arr[peek(stack)]) {
            pop(stack);
        }
        if (!isEmpty(stack)) {
            prevS[i] = peek(stack);
        }
        push(stack, i);
    }
}

// Function to calculate the maximum rectangular
// area in the Histogram
int getMaxArea(int arr[],int n) {

    int* prevS = (int*)malloc(n * sizeof(int));
    int* nextS = (int*)malloc(n * sizeof(int));
    int maxArea = 0;

    // Find previous and next smaller elements
    prevSmaller(arr, n, prevS);
    nextSmaller(arr, n, nextS);

    // Calculate the area for each arrogram bar
    for (int i = 0; i < n; i++) {
        int width = nextS[i] - prevS[i] - 1;
        int area = arr[i] * width;
        if (area > maxArea) {
            maxArea = area;
        }
    }
    return maxArea;
}

// Driver code
int main() {
    int arr[] = {60, 20, 50, 40, 10, 50, 60};
       int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d\n", getMaxArea(arr,n));
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

// Stack structure
struct Stack {
    int top;
    int capacity;
    int* array;
};

// Function to create a stack
struct Stack* createStack(int capacity) {
    struct Stack* stack = (struct Stack*)
                                malloc(sizeof(struct Stack));
    stack->capacity = capacity;
    stack->top = -1;
    stack->array = (int*)malloc(stack->capacity * sizeof(int));
    return stack;
}

int isEmpty(struct Stack* stack) {
    return stack->top == -1;
}

void push(struct Stack* stack, int item) {
    stack->array[++stack->top] = item;
}

int pop(struct Stack* stack) {
    return stack->array[stack->top--];
}

int peek(struct Stack* stack) {
    return stack->array[stack->top];
}

// Function to calculate the maximum rectangular area
int getMaxArea(int arr[],int n) {
    struct Stack* s = createStack(n);
    int res = 0, tp, curr;
    
    // Traverse all bars of the arrogram
    for (int i = 0; i < n; i++) {  
        
        // Process the stack while the current element 
        // is smaller than the element corresponding to 
        // the top of the stack
        while (!isEmpty(s) && arr[peek(s)] >= arr[i]) {
            tp = pop(s);
            
            // Calculate width and update result
            int width = isEmpty(s) ? i : i - peek(s) - 1;
            res = (res > arr[tp] * width) ? res : arr[tp] * width;
        }
        push(s, i);
    }

    // Process remaining elements in the stack
    while (!isEmpty(s)) {
        tp = pop(s);
        curr = arr[tp] * (isEmpty(s) ? n : n - peek(s) - 1);
        res = (res > curr) ? res : curr;
    }

    return res;
}

int main() {
    int arr[] = {60, 20, 50, 40, 10, 50, 60};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d\n", getMaxArea(arr,n));
    return 0;
}