剑指offer 栈的压入、弹出序列

没想到用栈，用了超级笨的方法，思路就是：
对于每个元素，比它先入栈且后出栈的元素（们）的出栈顺序必须是它们入栈顺序的逆序
举例来说：

• 例子1
  入栈序列 1 2 3 4 5
  出栈序列 5 4 3 1 2
  那么对于元素3，比它先入栈且后出栈的元素有1 2，但是其入栈顺序和出栈顺序都为 1 2，即不互为逆序
  所以是false
• 例子2
  入栈序列 1 2 3 4 5
  出栈序列 2 5 4 3 1
  对于元素2，比它先入栈且后出栈的元素有1，入栈出栈顺序互为逆序（只有一个元素）
  对于元素5，比它先入栈且后出栈的元素有4 3 1，入栈顺序（1 3 4）出栈顺序（4 3 1）互为逆序
  对于元素4，比它先入栈且后出栈的元素有3 1，入栈顺序（1 3）出栈顺序（3 1）互为逆序
  对于元素3，比它先入栈且后出栈的元素有1，入栈出栈顺序互为逆序（只有一个元素）
  对于元素1，没有比它先入栈且后出栈的元素
  所以是true

import java.util.ArrayList;
import java.util.Arrays;

public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        int len = pushA.length;
        int [] tmp1 = Arrays.copyOf(pushA, len);
        int [] tmp2 = Arrays.copyOf(popA, len);
        Arrays.sort(tmp1);
        Arrays.sort(tmp2);
        if (! Arrays.equals(tmp1, tmp2))
            return false;

        int [] index = Arrays.copyOf(pushA, len);
        for (int i = 0; i < len; i++) {
            index[i] = IndexinArray(pushA, popA[i]);
        }

        ArrayList<Integer> array = new ArrayList<Integer>();
        for (int j = 0; j < len; j++) {
            for (int k = j + 1; k < len; k++) {
                if (index[k] < index[j])
                    array.add(index[k]);
            }
            for (int l = 0; l < array.size() - 1; l++) {
                if (array.get(l) < array.get(l+1))
                    return false;
            }
            array.clear();
        }
        return true;
    }

    public int IndexinArray(int [] pushA, int x) {
        for (int i = 0; i < pushA.length; i++) {
            if (x == pushA[i])
                return i;
        }
        return pushA.length;
    }
}