栈的push、pop序列-实现

1、问题描述

      输入两个整数序列。其中一个序列表示栈的push顺序，判断另一个序列有没有可能是对应的pop顺序。为了简单起见，我们假设push序列的任意两个整数都是不相等的。

     比如输入的push序列是1、2、3、4、5，那么4、5、3、2、1就有可能是一个pop系列。因为可以有如下的push和pop序列：push 1，push 2，push 3，push 4，pop，push 5，pop，pop，pop，pop，这样得到的pop序列就是4、5、3、2、1。但序列4、3、5、1、2就不可能是push序列1、2、3、4、5的pop序列。

2、分析

      这道题的一个很直观的想法就是建立一个辅助栈，每次push的时候就把一个整数push进入这个辅助栈，同样需要pop的时候就把该栈的栈顶整数pop出来。

      我们以前面的序列4、5、3、2、1为例。第一个希望被pop出来的数字是4，因此4需要先push到栈里面。由于push的顺序已经由push序列确定了，也就是在把4 push进栈之前，数字1，2，3都需要push到栈里面。此时栈里的包含4个数字，分别是1，2，3，4，其中4位于栈顶。把4 pop出栈后，剩下三个数字1，2，3。接下来希望被pop的是5，由于仍然不是栈顶数字，我们接着在push序列中4以后的数字中寻找。找到数字5后再一次push进栈，这个时候5就是位于栈顶，可以被pop出来。接下来希望被pop的三个数字是3，2，1。每次操作前都位于栈顶，直接pop即可。

      再来看序列4、3、5、1、2。pop数字4的情况和前面一样。把4 pop出来之后，3位于栈顶，直接pop。接下来希望pop的数字是5，由于5不是栈顶数字，我们到push序列中没有被push进栈的数字中去搜索该数字，幸运的时候能够找到5，于是把5 push进入栈。此时pop 5之后，栈内包含两个数字1、2，其中2位于栈顶。这个时候希望pop的数字是1，由于不是栈顶数字，我们需要到push序列中还没有被push进栈的数字中去搜索该数字。但此时push序列中所有数字都已被push进入栈，因此该序列不可能是一个pop序列。

     也就是说，具体步骤如下：

1. 如果我们希望pop的数字正好是栈顶数字，直接pop出栈即可；
2. 如果希望pop的数字目前不在栈顶，我们就到push序列中还没有被push到栈里的数字中去搜索这个数字，并把在它之前的所有数字都push进栈。
3. 如果所有的数字都被push进栈仍然没有找到这个数字，表明该序列不可能是一个pop序列。

      代码中用到了辅助栈popS和相应的入栈pushS和可能出栈possible。下图给出了一个直观的表示。这里为了操作的方便，在输入的时候做了反转操作。入栈序列是{1,2,3,4，5}，但是为了后面获得栈顶元素为1，所以对于输入的入栈序列{1,2,3,4，5}反转，变成{5，4,3,2,1}，这样入栈后会变成图1所示的pushS结构，对可能出栈序列也做了一次反转操作。

       对于出栈序列中的top元素4，首先比较pushS中的栈顶元素1。由于不等，则把pushS中的栈顶元素push到pops中，一直到pops栈顶元素为4为止。变化之后为图2结构。然后依次根据分析中给出的步骤所述，进行判断。

算法代码为：

OrderStack pops = new OrderStack();

while (pushS.getStackSize() > 0 && pushS.top() != possible.top()) {
    pops.push(pushS.pop());
}
pops.push(pushS.pop());
pops.printStack();

while (possible.getStackSize() > 0) {
    // 如果辅助栈pops中栈顶元素与出栈possible中栈顶元素相同，则该元素出栈
    if (pops.getStackSize() > 0 && pops.top() == possible.top()) {
        pops.pop();
        possible.pop();
    }
    // 若不等，继续将pushS中数据压入到辅助栈pops中
    else if (pushS.getStackSize() > 0) {
        while (pushS.getStackSize() > 0
                && pushS.top() != possible.top()) {
            pops.push(pushS.pop());
        }
        //对pushS.pop()==possible.pop()的数据，从pushS中移除，压入到辅助栈
        pops.push(pushS.pop());
    }
    // pushS中无元素可压入辅助栈，说明不是可弹出的顺序，此时possible栈不为空
    else {
        break;
    }
}

if (possible.getStackSize() == 0) {
    return true;
} else {
    return false;
}

3、代码实现

    除了给利用自己构造的栈结构进行判断外，文中还利用了linkedlist数据结构进行判断。具体代码 如下。                                 

class OrderStack {
    // 栈的数据区
    private List<Object> list;
    // 栈顶指针
    private int topPointer;

    @SuppressWarnings("unchecked")
    public OrderStack() {
        this.list = new ArrayList();
        this.topPointer = -1;
    }

    @SuppressWarnings("unchecked")
    public OrderStack(List<Object> list, int topPointer) {
        if (null == list) {
            list = new ArrayList();
        }
        this.list = list;
        this.topPointer = list.size() - 1;
    }

    /**
     * 入栈方法
     */
    public void push(Object Object) {
        this.list.add(Object);
        topPointer++;
    }

    /**
     * 出栈方法
     */
    public Object pop() {
        if (!isEmpty()) {
            Object obj = this.list.remove(this.topPointer);
            this.topPointer--;
            return obj;
        } else {
            return null;
        }
    }

    /**
     * 判断栈是否为空
     */
    public boolean isEmpty() {
        if (topPointer == -1) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 获取栈的大小
     */
    public int getStackSize() {
        return this.list.size();
    }

    /**
     * 返回栈顶元素
     */
    public Object top() {
        if (topPointer == -1) {
            return null;
        } else {
            return list.get(topPointer);
        }
    }

    /**
     * 遍历栈的内部数据信息:按list打印出数据
     */
    public void printStack() {
        if (this.list.size() > 0) {
            //System.out.println("The data int stack is:");
            for (int i = 0; i < list.size(); i++) {
                System.out.print(this.list.get(i).toString() + "  ");
            }
            System.out.println();
        } else {
            System.out.println("The stack is empty!");
        }
    }

    public List<Object> getList() {
        return list;
    }

    public void setList(List<Object> list) {
        this.list = list;
    }

    public int getTopPointer() {
        return topPointer;
    }

    public void setTopPointer(int topPointer) {
        this.topPointer = topPointer;
    }
}

public class PossiblePopOrder {
    public static boolean isPossiblePopOrder(LinkedList<Integer> queue,
            LinkedList<Integer> possible) {
        LinkedList<Integer> pops = new LinkedList<Integer>();
        LinkedList<Integer> leftpush = new LinkedList<Integer>();
        while (queue.size() > 0 && queue.getFirst() != possible.getFirst()) {
            pops.add(queue.remove());
        }
        pops.add(queue.remove());
        leftpush.addAll(queue);

        // 注意LinkedList 数据结构的特点
        while (possible.size() > 0) {
            if (pops.size() > 0 && pops.getLast() == possible.getFirst()) {
                pops.removeLast();
                possible.remove();
            } else if (leftpush.size() > 0) {
                while (leftpush.size() > 0
                        && leftpush.getFirst() != possible.getFirst()) {
                    pops.add(leftpush.remove());
                }
                //将leftpush.getFirst()==possible.getFirst()的数据，从leftpush中移除
                pops.add(leftpush.remove());
            } else {
                break;
            }
        }
        if (possible.size() == 0) {
            return true;
        } else {
            return false;
        }
    }

    static void printLinkedList(LinkedList<Integer> list) {
        for (int i = 0; i < list.size(); i++)
            System.out.print(list.get(i) + " ");
        System.out.println();
    }

    public static boolean isPossiblePopOrder(OrderStack pushS,
            OrderStack possible) {

        /*
         *             辅助栈      入栈      出栈
         *              pops     pushS   possible
         *   top                    1       4
         *                          2       5
         *                            3         3
         *                          4       2
         *   base                   5         1
         * */

        /*
         *             辅助栈      入栈      出栈
         *              pops     pushS   possible
         *   top          4         5       4
         *                3                 5
         *                  2                   3
         *                1                 2
         *   base                             1
         * */
        OrderStack pops = new OrderStack();

        while (pushS.getStackSize() > 0 && pushS.top() != possible.top()) {
            pops.push(pushS.pop());
        }
        pops.push(pushS.pop());
        //pops.printStack();

        while (possible.getStackSize() > 0) {
            // 如果辅助栈pops中栈顶元素与出栈possible中栈顶元素相同，则该元素出栈
            if (pops.getStackSize() > 0 && pops.top() == possible.top()) {
                pops.pop();
                possible.pop();
            }
            // 若不等，继续将pushS中数据压入到辅助栈pops中
            else if (pushS.getStackSize() > 0) {
                while (pushS.getStackSize() > 0
                        && pushS.top() != possible.top()) {
                    pops.push(pushS.pop());
                }
                //对pushS.pop()==possible.pop()的数据，从pushS中移除，压入到辅助栈
                pops.push(pushS.pop());
            }
            // pushS中无元素可压入辅助栈，说明不是可弹出的顺序，此时possible栈不为空
            else {
                break;
            }
        }

        if (possible.getStackSize() == 0) {
            return true;
        } else {
            return false;
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LinkedList<Integer> queue = new LinkedList<Integer>();
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);
        queue.add(5);
        LinkedList<Integer> possible = new LinkedList<Integer>();
        possible.add(4);
        possible.add(5);
        possible.add(3);
        possible.add(2);
        possible.add(1);
        System.out.println(isPossiblePopOrder(queue, possible));

        queue = new LinkedList<Integer>();
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);
        queue.add(5);
        LinkedList<Integer> possible2 = new LinkedList<Integer>();
        possible2.add(4);
        possible2.add(3);
        possible2.add(5);
        possible2.add(1);
        possible2.add(2);
        System.out.println(isPossiblePopOrder(queue, possible2));

        queue = new LinkedList<Integer>();
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);
        queue.add(5);
        LinkedList<Integer> possible3 = new LinkedList<Integer>();
        possible3.add(2);
        possible3.add(3);
        possible3.add(5);
        possible3.add(1);
        possible3.add(4);
        System.out.println(isPossiblePopOrder(queue, possible3));

        OrderStack pushS = new OrderStack();
        int[] arr = { 5, 4, 3, 2, 1 };//{1,2,3,4,5}; //push入栈序列反转
        for (int data : arr)
            pushS.push(data);
        //pushS.printStack();
        //System.out.println(pushS.top());
        OrderStack popS = new OrderStack();
        int[] arr2 = { 1, 2, 5, 3, 4 };//{4,3,5,1,2}; // pop出栈序列反转
        for (int data : arr2)
            popS.push(data);
        //popS.printStack();

        System.out.println(isPossiblePopOrder(pushS, popS));
    }

}

参考资料：

http://zhedahht.blog.163.com/blog/static/25411174200732102055385/