输入两个整数序列。其中一个序列表示栈的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结构。然后依次根据分析中给出的步骤所述，进行判断。
算法代码为：
new OrderStack();
2:
while (pushS.getStackSize() > 0 && pushS.top() != possible.top()) {
4: pops.push(pushS.pop());
5: }
6: pops.push(pushS.pop());
7: pops.printStack();
8:
while (possible.getStackSize() > 0) {
// 如果辅助栈pops中栈顶元素与出栈possible中栈顶元素相同，则该元素出栈
if (pops.getStackSize() > 0 && pops.top() == possible.top()) {
12: pops.pop();
13: possible.pop();
14: }
// 若不等，继续将pushS中数据压入到辅助栈pops中
if (pushS.getStackSize() > 0) {
while (pushS.getStackSize() > 0
18: && pushS.top() != possible.top()) {
19: pops.push(pushS.pop());
20: }
//对pushS.pop()==possible.pop()的数据，从pushS中移除，压入到辅助栈
22: pops.push(pushS.pop());
23: }
// pushS中无元素可压入辅助栈，说明不是可弹出的顺序，此时possible栈不为空
else {
break;
27: }
28: }
29:
if (possible.getStackSize() == 0) {
return true;
else {
return false;
34: }
3、代码实现
除了给利用自己构造的栈结构进行判断外，文中还利用了linkedlist数据结构进行判断。具体代码 如下。
class OrderStack {
// 栈的数据区
private List<Object> list;
// 栈顶指针
int topPointer;
6:
)
public OrderStack() {
new ArrayList();
this.topPointer = -1;
11: }
12:
)
int topPointer) {
if (null == list) {
new ArrayList();
17: }
this.list = list;
this.topPointer = list.size() - 1;
20: }
21:
/**
* 入栈方法
*/
void push(Object Object) {
this.list.add(Object);
27: topPointer++;
28: }
29:
/**
* 出栈方法
*/
public Object pop() {
if (!isEmpty()) {
this.topPointer);
this.topPointer--;
return obj;
else {
return null;
40: }
41: }
42:
/**
* 判断栈是否为空
*/
boolean isEmpty() {
if (topPointer == -1) {
return true;
else {
return false;
51: }
52: }
53:
/**
* 获取栈的大小
*/
int getStackSize() {
this.list.size();
59: }
60:
/**
* 返回栈顶元素
*/
public Object top() {
if (topPointer == -1) {
return null;
else {
return list.get(topPointer);
69: }
70: }
71:
/**
* 遍历栈的内部数据信息:按list打印出数据
*/
void printStack() {
this.list.size() > 0) {
int i = 0; i < list.size(); i++) {
);
80: }
81: System.out.println();
else {
);
84: }
85: }
86:
public List<Object> getList() {
return list;
89: }
90:
void setList(List<Object> list) {
this.list = list;
93: }
94:
int getTopPointer() {
return topPointer;
97: }
98:
int topPointer) {
this.topPointer = topPointer;
101: }
102: }
103:
class PossiblePopOrder {
boolean isPossiblePopOrder(LinkedList<Integer> queue,
106: LinkedList<Integer> possible) {
new LinkedList<Integer>();
new LinkedList<Integer>();
while (queue.size() > 0 && queue.getFirst() != possible.getFirst()) {
110: pops.add(queue.remove());
111: }
112: pops.add(queue.remove());
113: leftpush.addAll(queue);
114:
// 注意LinkedList 数据结构的特点
while (possible.size() > 0) {
if (pops.size() > 0 && pops.getLast() == possible.getFirst()) {
118: pops.removeLast();
119: possible.remove();
if (leftpush.size() > 0) {
while (leftpush.size() > 0
122: && leftpush.getFirst() != possible.getFirst()) {
123: pops.add(leftpush.remove());
124: }
//将leftpush.getFirst()==possible.getFirst()的数据，从leftpush中移除
126: pops.add(leftpush.remove());
else {
break;
129: }
130: }
if (possible.size() == 0) {
return true;
else {
return false;
135: }
136: }
137:
void printLinkedList(LinkedList<Integer> list) {
int i = 0; i < list.size(); i++)
);
141: System.out.println();
142: }
143:
boolean isPossiblePopOrder(OrderStack pushS,
145: OrderStack possible) {
146:
/*
* 辅助栈 入栈 出栈
* pops pushS possible
* top 1 4
* 2 5
* 3 3
* 4 2
* base 5 1
* */
156:
/*
* 辅助栈 入栈 出栈
* pops pushS possible
* top 4 5 4
* 3 5
* 2 3
* 1 2
* base 1
* */
new OrderStack();
167:
while (pushS.getStackSize() > 0 && pushS.top() != possible.top()) {
169: pops.push(pushS.pop());
170: }
171: pops.push(pushS.pop());
//pops.printStack();
173:
while (possible.getStackSize() > 0) {
// 如果辅助栈pops中栈顶元素与出栈possible中栈顶元素相同，则该元素出栈
if (pops.getStackSize() > 0 && pops.top() == possible.top()) {
177: pops.pop();
178: possible.pop();
179: }
// 若不等，继续将pushS中数据压入到辅助栈pops中
if (pushS.getStackSize() > 0) {
while (pushS.getStackSize() > 0
183: && pushS.top() != possible.top()) {
184: pops.push(pushS.pop());
185: }
//对pushS.pop()==possible.pop()的数据，从pushS中移除，压入到辅助栈
187: pops.push(pushS.pop());
188: }
// pushS中无元素可压入辅助栈，说明不是可弹出的顺序，此时possible栈不为空
else {
break;
192: }
193: }
194:
if (possible.getStackSize() == 0) {
return true;
else {
return false;
199: }
200: }
201:
void main(String[] args) {
// TODO Auto-generated method stub
new LinkedList<Integer>();
205: queue.add(1);
206: queue.add(2);
207: queue.add(3);
208: queue.add(4);
209: queue.add(5);
new LinkedList<Integer>();
211: possible.add(4);
212: possible.add(5);
213: possible.add(3);
214: possible.add(2);
215: possible.add(1);
216: System.out.println(isPossiblePopOrder(queue, possible));
217:
new LinkedList<Integer>();
219: queue.add(1);
220: queue.add(2);
221: queue.add(3);
222: queue.add(4);
223: queue.add(5);
new LinkedList<Integer>();
225: possible2.add(4);
226: possible2.add(3);
227: possible2.add(5);
228: possible2.add(1);
229: possible2.add(2);
230: System.out.println(isPossiblePopOrder(queue, possible2));
231:
new LinkedList<Integer>();
233: queue.add(1);
234: queue.add(2);
235: queue.add(3);
236: queue.add(4);
237: queue.add(5);
new LinkedList<Integer>();
239: possible3.add(2);
240: possible3.add(3);
241: possible3.add(5);
242: possible3.add(1);
243: possible3.add(4);
244: System.out.println(isPossiblePopOrder(queue, possible3));
245:
new OrderStack();
//{1,2,3,4,5}; //push入栈序列反转
int data : arr)
249: pushS.push(data);
//pushS.printStack();
//System.out.println(pushS.top());
new OrderStack();
//{4,3,5,1,2}; // pop出栈序列反转
int data : arr2)
255: popS.push(data);
//popS.printStack();
257:
258: System.out.println(isPossiblePopOrder(pushS, popS));
259: }
260:
261: }
参考资料：
http://zhedahht.blog.163.com/blog/static/25411174200732102055385/