面试算法：堆栈元素的在线排序

更详细的讲解和代码调试演示过程，请参看视频

如何进入google,算法面试技能全面提升指南

给定一个存有整形数的堆栈，你能使用的操作有，peek 获得堆栈顶部元素的值但不把元素弹出堆栈，pop 把堆栈顶部的元素出栈，push 压入一个堆栈，empty 判断堆栈是否为空，要求你只能使用这几种操作，同时在不分配新内存的情况下，将堆栈中的元素从大到小排列，假定堆栈中，元素由栈底到栈顶如下：

stack: 1 3 5 4 2

排序后为：

stack: 5 4 3 2 1

这道题的麻烦点在于，我们不能分配新的内存，如果可以的话，我们可以先构造另一个堆栈，把原堆栈的元素全部弹到新堆栈中，同时记录下元素中的最大值，然后把最大值压入元堆栈，再把新堆栈中的所有元素除去其中的最大值压入原堆栈，这样一来，堆栈元素中的最大值就压入底部了，这个过程反复进行，最后就可以完成所需要的排序。

但题目有一苛刻之处在于，不能分配新内存，也就是我们不能分配另一个临时堆栈，所以我们必须另辟蹊径。

假设我们已经有了一个按照规则排好序的堆栈如下：

stack: 1

2

4

5

此时我们有遇到3，那么该怎么处理？办法就是先把1，2弹出栈，把3压入，然后再把2，1分别压入堆栈。问题在于，弹出堆栈的元素可能有好几个，题目要求

不能用new 分配新内存，所以当我们需要弹出多个元素时，这些弹出的元素怎么存放？我们这里可以采用一种递归调用的技巧，将弹出的元素存储在调用堆栈上，我们先看看代码：

private Stack<Integer> insert(Stack<Integer> s, int v) {
if (s.empty() == true || v <= s.peek()) {
s.push(v);
return s;
}

int t = s.pop();
insert(s, v);
s.push(t);

return s;
}

insert 的作用是把数值v插入已经排好序的堆栈s, 如果s是空的，或者要压入的数值小于栈顶元素，那么直接把该数值压入栈顶即可，如果数值大于栈顶元素，那么先把栈顶元素弹出存储在变量t中，变量t的内存来自当前的调用堆栈，然后再递归的调用insert，继续将数值v插入堆栈，由于堆栈s中的元素已经排好序，因此即使弹出s的栈顶元素，堆栈s剩下的元素仍然是排好序的，因此insert逻辑可以递归的运行下去。

根据例子，要把元素3插入堆栈，insert第一次调用时，会把栈顶元素1弹出，然后继续执行insert的函数逻辑，第二次调用时，再次把堆栈顶部的元素2弹出，然后再次执行insert函数逻辑。第三次执行insert函数时，堆栈顶部元素是4，此时直接把3压入栈顶，然后往回退出函数，回退时，分别把原来弹出的元素2，1，依次重新压入堆栈，最后元素3就会插入到堆栈中的恰当位置。

接下来的问题是，insert函数的调用需要保证传入的堆栈s，其中元素已经是排好序的，那么怎么满足这一点呢？实现堆栈排序的代码如下：

public Stack<Integer> sortByRecursion(Stack<Integer> s) {
if (s.empty() == true) {
return s;
}

int v = s.pop();
s = sortByRecursion(s);
s = insert(s, v);

return s;
}

上面代码的逻辑在于，如果一个堆栈是空的，那么它就已经是排好序的堆栈了，此时可以使用insert函数将元素插入堆栈，所以对堆栈排序时，现将栈顶元素弹出，把剩下的堆栈元素进行排序，排好序后，把原来栈顶元素使用insert重新插入堆栈即可。因此sortByRecursion的逻辑是一种递归调用，要将含有n个元素的堆栈进行排序，可以先把n-1个元素的堆栈排好序，然后把第n个元素通过调用insert插入即可，这个逻辑一直通过递归调用的方式往下走，知道堆栈为空，那么此时堆栈就已经是排好序的，于是直接将元素插入空堆栈。

由此整个算法的实现如下：

import java.util.Stack;

public class StackSorter  {

public Stack<Integer> sortByRecursion(Stack<Integer> s) {
if (s.empty() == true) {
return s;
}

int v = s.pop();
s = sortByRecursion(s);
s = insert(s, v);

return s;
}

private Stack<Integer> insert(Stack<Integer> s, int v) {
if (s.empty() == true || v <= s.peek()) {
s.push(v);
return s;
}

int t = s.pop();
insert(s, v);
s.push(t);

return s;
}

}

程序入口处的代码为：

import java.util.Random;
import java.util.Stack;

public class StackAndQuque {
public static void main(String[] args) {

Stack<Integer> s = new Stack<Integer>();
StackSorter sorter = new StackSorter();

Random r = new Random();
for (int i = 0; i < 5; i++) {
s.push(r.nextInt(10));
}
sorter.sortByRecursion(s);
}
}

上面代码先在堆栈s中压入若干个随机数，然后调用sortByRecursion进行排序，上面代码运行后，s中的元素可以由原来的无序转变为符合题目要求的有序排列。

这道题的解法思路有两大特点，一是利用递归调用的方式，将原来需要使用新内存来存储的信息，直接存储到调用堆栈上。第二是如同上一节解决汉诺塔的思路，要处理一个规模为n的问题，转换为先处理规模小一点的n-1个级别的问题，将大问题一路分解成小问题，直到小问题非常容易解决为止。

更详细的算法讲解和代码调试演示，请参看视频。

更多技术信息，包括操作系统，编译器，面试算法，机器学习，人工智能，请关照我的公众号：