有许多方法可以完成分离奇数和偶数元素的任务。
我怀疑这一挑战的目的是熟悉Stack data structure及其基本操作。
这里有一个解决方案，它利用两个额外的堆栈，一个用于累积奇数元素，另一个用于存储偶数元素。
初始堆栈被清空，其元素分布在其他两个堆栈之间。现在将奇数和偶数分开，剩下的唯一一件事就是连接数据。
该解的时间复杂度为线性O（n）。它比数据排序更高效，它将具有线性对数时间复杂度O（n log n）。
如何实施：

Stack<Integer> numbers = new Stack<>();

numbers.push(3);
numbers.push(4);
numbers.push(1);
numbers.push(7);
numbers.push(6);
numbers.push(2);
numbers.push(5);

Stack<Integer> odd = new Stack<>();
Stack<Integer> even = new Stack<>();

while (!numbers.isEmpty()) {
    Integer next = numbers.pop();
    if (next % 2 == 0) even.push(next);
    else odd.push(next);
}

numbers.addAll(odd);
numbers.addAll(even);

System.out.println(numbers);

• 输出：*

[5, 7, 1, 3, 2, 6, 4]

注：

• Stack类是遗留类，不应使用（除非您的任务要求）。当您需要在Java中实现堆栈数据结构时，建议使用Deque接口的实现。
• 尝试使用比p更有意义的名称。这是一个好习惯，因为它使代码更易于阅读和维护。单字母变量仅在极少数情况下可接受，如for循环中定义的变量。另见Java Language Naming Conventions。

Stack是AbstractList的子类，因此可以使用列表。通过提供自定义Comparator进行排序（）。

public class Temp {

    public static void main(String[] args) {
        Stack<Integer> p = new Stack<>();

        p.push(3);
        p.push(4);
        p.push(1);
        p.push(7);
        p.push(6);
        p.push(2);
        p.push(5);

        p.sort((a, b) -> {
            if (a % 2 == 0 && b % 2 == 0) {
                return 0;
            }
            if (a % 2 == 0) {
                return 1;
            }
            if (b % 2 == 0) {
                return -1;
            }
            return 0;
        });
        System.out.println(p);
    }
}

对于-[3, 4, 1, 7, 6, 2, 5]的初始堆栈，这将导致-[3, 1, 7, 5, 4, 6, 2]。

比较模2之间的取反（因此1的阶数在0之前）差：

p.sort((a, b) -> b % 2 - a % 2);

见live demo。