按升序排序堆栈？

Question

What is the best method for sorting a stack in ascending order? I came across this interview question, and I was running into some problems for the best and most efficient solution.

There are two methods that I can think of.

1. To pop all the contents of the stack and store them in an array, and then sort the array in
   O(nLog n) and then push the contents back the stack. Not the best way....

2. Do the recursive implementation of the stack for sorting it

void sort(stack)
{
    type x;

    if (!isEmpty(stack)) {
        x = pop(stack);
        sort(stack);
        insert(x, stack);
    }           
}

void insert(x, stack)
{
    type y;

    if (!isEmpty(stack) && top(stack) < x) {
        y = pop(stack);
        insert(x, stack);
        push(y, stack);
    } 
    else {
        push(x, stack);
    }
} 

But the 2nd method seems to be making too many recursive calls and the overhead will be a problem if the stack happens to be really big.

Is it possible to solve this problem in a much better way for the best space and time complexity?

There are so many recursive calls, (overlapping subproblems), is this a contender for dynamic programming type of problems?

What would be the best way to solve this? ?

Answer 1

It's a stack. You can't see anything but the top value. You'll have to pop everything at least once, and push everything at least once. The first method is fine.

If the stack operations are expensive but you have a time deadline, use insertion sort as you're popping and you can push as soon as your last pop is done. But you're saying this is in C++ so I doubt we are considering such a scenario.

Answer 2

You can solve by eliminating the recursion. For this you just use a loop iterating under a stack until it is empty.

For example, pseudo code:

Linekd Stack stack = new List ();

while stack is not empty then

     element <- stack removes peek

     / / Recursiong
     push new elements on stack

end

Answer 3

This problem cant have complexity less than O(n^2). For further reference refer here