栈的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序列。

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

如果我们希望pop的数字正好是栈顶数字，直接pop出栈即可；

如果希望pop的数字目前不在栈顶，我们就到push序列中还没有被push到栈里的数字中去搜索这个数字，并把在它之前的所有数字都push进栈。

如果所有的数字都被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

* top1 4

*2 5

*3 3

*4 2

* base 5 1

* */

 /*

* 辅助栈入栈出栈

*pops pushS possible

* top4 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/