Question

我想知道这个算法的时间复杂度，它用于使用另一个堆栈对堆栈进行排序。我认为它是O（N ^ 2），但显然它看起来不止于此。

public static Stack<Integer> sort(Stack<Integer> s) {
    Stack<Integer> r = new Stack<Integer>();

    while(!s.isEmpty()) {
        int tmp = s.pop();
        while(!r.isEmpty() && r.peek() > tmp) {
            s.push(r.pop());
        }
        r.push(tmp);
    }
    return r;
}

Answer 1

如果排序堆栈[x_2, .., x_n]（堆栈向右增长）花费t(n-1)时间，则排序堆栈[x_1, .., x_n]将执行以下操作

排序[x_2, .., x_n]

s

弹出x_1至tmp
最多将n-1元素从r转移到s
将x_1推送至r
再次处理在步骤3中传输的元素，但它们的顺序是内部while循环而从不运行。

因此，在[x_1, .., x_n]上运行算法最多只需t(n-1) + O(n)次。这导致（对于某些常数c）

t(n) <= O(n) + t(n-1) <= c * n + t(n-1)
t(n) <= c * n + c * (n - 1) + t(n-2) <= ... <= c * (1 + 2 + ... + n)
t(n) <= c * n(n + 1) / 2

所以t(n)是O(n^2)。

Answer 2

向我看O（n ^ 2）。我猜测已经排序的堆栈具有最差的性能。考虑到已经排序的特定大小的堆栈，我计算了s.push执行的次数。

Stack of size 1. backpushes: 0
Stack of size 2. backpushes: 1
Stack of size 3. backpushes: 3
Stack of size 4. backpushes: 6
Stack of size 5. backpushes: 10
Stack of size 6. backpushes: 15
Stack of size 7. backpushes: 21
Stack of size 8. backpushes: 28
Stack of size 9. backpushes: 36

0,1,3,6,10是triangular numbers的序列。大小为N的排序堆栈需要（N ^ 2 + N）/ 2个反推。这使它成为O（N ^ 2）。

Answer 3

这个问题可以在o（n ^ 2）复杂度下完成。这可以在不使用弹出最大数字并在第二个堆栈中存储rest元素并更新第一个堆栈的大小，然后再推回到第一个堆栈的情况下完成。 stack.Have看一下代码片段。

   #include<stdio.h>
            func(struct stack *s1)
            {
                            struct stack* s2=(struct stack*) malloc(sizeof(struct stack))
                            int i=0;
                            int max=INT_MIN;
                            size=s1->size;
                            if(s1->size==0)
                            {
                                return;
                            }
                            for(;i<size;i++)
                            {

                                while(size(s1)!=size)//popping the elements and pushing in s2 stack and keeping track of maximum element.
                                {

                                    temp=pop(s1);
                                    if(temp>max)
                                    {

                                        push(s2,max);
                                        max=temp;
                                    }

                                }
                                push(s1,max);//pushing the max element into stack s1 back and updating the size in push operation.
                                while(!empty(s2))//pushing extracted numbers back into stack s1 from s2.
                                {
                                    push(s1,pop(s2));

                                }

                            }


        }

使用另一个堆栈对堆栈进行排序

3 个答案: