Topic: stack-problem / Level: intermediate

• 1001. Implement a stack to evaluate a postfix expression.
• 1002. Write a program to sort a stack using recursion.
• 1003. Design a function to convert an infix expression to a postfix expression using a stack.
• 1004. Implement a stack to simulate a queue (queue using two stacks).
• 1005. Write a program to check if a string has balanced parentheses using a stack.
• 1006. Design a stack that supports getMin() in constant time without using additional stacks.
• 1007. Implement a function to reverse a stack using recursion without using any additional stack.
• 1008. Write a program to sort a stack such that the smallest elements are on the top.
• 1009. Create a function to find the next greater element for each element in an array using a stack.
• 1010. Implement a stack to find the longest valid substring of parentheses.
• 1011. Write a program to implement a basic calculator using a stack for handling operations and parentheses.
• 1012. Design a function to check if two stacks contain the same sequence of elements.
• 1013. Implement a function to push elements into a stack and find the span of stock prices.
• 1014. Write a program to convert a decimal number to binary using a stack.
• 1015. Design a stack-based function to evaluate an arithmetic expression in infix notation.
• 1016. Create a function to sort a stack using another stack.
• 1017. Write a program to find the maximum area of a histogram using a stack.
• 1018. Implement a stack to simulate undo/redo operations in a text editor.
• 1019. Design a function to check if two stacks are mirror images of each other.
• 1020. Write a program to implement the Tower of Hanoi using a stack.
• 1021. Create a function to find the maximum of each sliding window of size k in an array using a stack.
• 1022. Implement a stack that can reverse a linked list in O(n) time.
• 1023. Write a program to find the next smaller element for each element in an array using a stack.
• 1024. Design a function to evaluate an arithmetic expression in prefix notation using a stack.
• 1025. Implement a stack to check if a series of stack operations is valid for a given output sequence.
• 1026. Write a program to implement the LRU (Least Recently Used) cache using a stack.
• 1027. Create a function to reverse the order of words in a sentence using a stack.
• 1028. Implement a stack that supports finding the middle element in constant time.
• 1029. Write a program to calculate the largest rectangle under the skyline using a stack.
• 1030. Design a function to check if a stack sequence is possible given a set of push/pop operations.
• 1031. Implement a stack to validate the execution order of function calls in a program.
• 1032. Write a program to simulate a browsers forward and backward functionality using stacks.
• 1033. Create a function to check if an array can be sorted by a series of stack operations.
• 1034. Implement a stack that supports finding the kth largest element in O(1) time.
• 1035. Write a program to evaluate an arithmetic expression with exponents using a stack.
• 1036. Design a stack that supports multi-level undo/redo operations for text editing.
• 1037. Implement a stack to convert a postfix expression to an infix expression.
• 1038. Write a program to check if a given set of brackets is balanced using multiple types of brackets.
• 1039. Create a function to evaluate a boolean expression using a stack.
• 1040. Implement a stack that can handle pushing and popping of custom objects with attributes.
• 1041. Write a program to find the largest element on the left of each element in an array using a stack.
• 1042. Design a function to find the celebrity in a party using a stack.
• 1043. Implement a stack-based depth-first search (DFS) traversal for a graph.
• 1044. Write a program to find the longest sequence of balanced parentheses using a stack.
• 1045. Create a function to merge two stacks in sorted order.
• 1046. Implement a stack to store function call frames for a recursive algorithm.
• 1047. Write a program to check if a sequence of parentheses can be made balanced by adding at most one pair.
• 1048. Design a stack-based approach to simulate a card game where players draw and discard cards.
• 1049. Implement a stack to find the nearest greater and smaller elements for each element in an array.
• 1050. Write a program to evaluate a postfix expression with support for exponential operations.

• More Levels

• Beginner
• Advanced