本文介绍了一种仅使用递归函数和栈操作实现栈逆序的方法。通过详细解析两种实现方案，包括使用辅助栈和单栈递归操作，展示了如何在不引入额外数据结构的情况下完成栈元素的逆序。
/**
* 如何仅用递归函数和栈操作逆序一个栈* 题目：
* 一个栈依次压入1，2，3，4，5，那么从栈顶到栈底分别为5，4，3，2，1。
* 将这个栈转置后，从栈顶到栈底为1，2，3，4，5，也就是实现栈中元素的逆序，
* 但是只能用递归函数来实现，不能用其他数据结构。
* @author GPJ
*
*/
方法一：
既然是递归，第一反应是采用两个栈实现该功能实现，依次弹出栈顶元素，然后压入另外一个栈中，代码如下：
package stack_queue;
import java.util.Stack;
/**
* 如何仅用递归函数和栈操作逆序一个栈
* 题目：
* 一个栈依次压入1，2，3，4，5，那么从栈顶到栈底分别为5，4，3，2，1。
* 将这个栈转置后，从栈顶到栈底为1，2，3，4，5，也就是实现栈中元素的逆序，
* 但是只能用递归函数来实现，不能用其他数据结构。
* @author GPJ
*/
public class StackReverse0 {
private Stack<Integer> stack0;
private Stack<Integer> stack1;
public StackReverse0(){
stack0 = new Stack<Integer>();
stack1 = new Stack<Integer>();
}
public void getLastElement(){
Integer pop = stack0.pop();
stack1.push(pop);
if(!stack0.isEmpty())
getLastElement();
}
public static void main(String[] args) {
StackReverse0 sr = new StackReverse0();
sr.stack0.add(1);
sr.stack0.add(2);
sr.stack0.add(3);
sr.stack0.add(4);
sr.stack0.add(5);
sr.getLastElement();
System.out.println(sr.stack1.pop());
System.out.println(sr.stack1.pop());
System.out.println(sr.stack1.pop());
System.out.println(sr.stack1.pop());
System.out.println(sr.stack1.pop());
}
}方法二：
方法一是采用两个栈，那能不能只使用一个栈实现呢，那么第一反应的问题是如何把栈顶元素压入栈底。因为题目说必须使用递归实现，由于递归可以认为是方法1调用克隆方法1(记为方法2)在调用克隆方法1(记为方法3)这样的方法1和2和3的入栈出栈的过程，那么方法1在调用方法2的时候，方法2中的局部变量不受方法1的影响。那么可以实验一个最简单的例子进行测试实验。比如依次压栈1，2，3，此时的栈中元素如下：
此时把3弹栈，然后递归到2弹栈，再1弹栈，此时栈空，把3压栈，返回，再1压栈，再2压栈，3出栈-->2出栈-->1出栈-->3入栈-->1入栈-->2入栈，栈中元素就如下所示：
重复此过程就最终栈中元素变为如下形式：
很显然满足题目条件，那么基本思路有了，接下来开始完善细节，看是否存在可行性。
思路如下：
当3出栈，2出栈，1出栈后，此时栈为空，因此开始递归返回，返回条件是栈空，此步可行。此时的栈中元素从栈顶到栈底依次为[2，1，3]
当2出栈，1出栈，很显然不需要3再次出栈了，此时的判定条件就发生了变化，无法使用栈是否为空作为递归返回条件了，那么此时肯定是需要一个标志来判断是否递归返回，我有两种思路：
第一种思路是采用字符串，没向下递归一次，就字符串加0，当第一次访问到栈底时，此时改为加1，那么下次重新递归时判断下一个出栈操作是否对应于1，如果为1则直接递归返回，可行。
第二种思路是每向下递归一次就有一个标志变量加1，记录此时向下的深度，还需要另外一个标志变量来记录已经处于正确位置的元素的深度，当两个标志变量相等时，那么就递归返回，同时记录递归深度的标志变量要减一，表示下次递归的深度减一，可行。
根据这个思路，代码如下：
package stack_queue;
import java.util.Stack;
/**
* 如何仅用递归函数和栈操作逆序一个栈
* 题目：
* 一个栈依次压入1，2，3，4，5，那么从栈顶到栈底分别为5，4，3，2，1。
* 将这个栈转置后，从栈顶到栈底为1，2，3，4，5，也就是实现栈中元素的逆序，
* 但是只能用递归函数来实现，不能用其他数据结构。
* @author GPJ
*
*/
public class StackReverse2 {
private Stack<Integer> stack;
private boolean SB;
private Integer SBCount;
private Integer SBDepth;
public StackReverse2(){
stack = new Stack<Integer>();
SB = false;
SBCount = 0;
SBDepth = 0;
}
public void m(){
SBDepth = 0;
Integer p0 = stack.pop();
SBCount = 1;
m(p0);
while(true){
if(SBDepth == 1 && SB) break;
else{
p0 = stack.pop();
SBCount = 1;
m(p0);
}
}
}
public void m(Integer p0){
Integer p1 = stack.pop();
SBCount++;
if(SBDepth == SBCount){
stack.push(p0);
stack.push(p1);
SBDepth--;
return;
}
/*if(stack.isEmpty()){
SB = true;
SBDepth = SBCount - 1;
}
if(SB)
stack.push(p0);
else
m(p0);*/
if(stack.isEmpty()){
SB = true;
SBDepth = SBCount - 1;
stack.push(p0);
}else
m(p0);
stack.push(p1);
}
public static void main(String[] args) {
StackReverse2 sr = new StackReverse2();
sr.stack.add(1);
sr.stack.add(2);
sr.stack.add(3);
sr.stack.add(4);
sr.stack.add(5);
sr.m();
System.out.println(sr.stack.pop());
System.out.println(sr.stack.pop());
System.out.println(sr.stack.pop());
System.out.println(sr.stack.pop());
System.out.println(sr.stack.pop());
}
}while循环可以使用递归代替，再一次按题目要求优化如下：
package stack_queue;
import java.util.Stack;
/**
* 如何仅用递归函数和栈操作逆序一个栈
* 题目：
* 一个栈依次压入1，2，3，4，5，那么从栈顶到栈底分别为5，4，3，2，1。
* 将这个栈转置后，从栈顶到栈底为1，2，3，4，5，也就是实现栈中元素的逆序，
* 但是只能用递归函数来实现，不能用其他数据结构。
* @author GPJ
*
*/
public class StackReverse2 {
private Stack<Integer> stack;
private boolean SB;
private Integer SBCount;
private Integer SBDepth;
public StackReverse2(){
stack = new Stack<Integer>();
SB = false;
SBCount = 0;
SBDepth = 0;
}
public void m(){
Integer p0 = stack.pop();
SBCount = 1;
m(p0);
if(SBDepth == 1 && SB)
return;
else
m();
}
public void m(Integer p0){
Integer p1 = stack.pop();
SBCount++;
if(SBDepth == SBCount){
stack.push(p0);
stack.push(p1);
SBDepth--;
return;
}
/*if(stack.isEmpty()){
SB = true;
SBDepth = SBCount - 1;
}
if(SB)
stack.push(p0);
else
m(p0);*/
if(stack.isEmpty()){
SB = true;
SBDepth = SBCount - 1;
stack.push(p0);
}else
m(p0);
stack.push(p1);
}
public static void main(String[] args) {
StackReverse2 sr = new StackReverse2();
sr.stack.add(1);
sr.stack.add(2);
sr.stack.add(3);
sr.stack.add(4);
sr.stack.add(5);
sr.m();
System.out.println(sr.stack.pop());
System.out.println(sr.stack.pop());
System.out.println(sr.stack.pop());
System.out.println(sr.stack.pop());
System.out.println(sr.stack.pop());
}
}成功运行！
原答案解法：
package stack_queue;
import java.util.Stack;
/**
* 如何仅用递归函数和栈操作逆序一个栈
* 题目：
* 一个栈依次压入1，2，3，4，5，那么从栈顶到栈底分别为5，4，3，2，1。
* 将这个栈转置后，从栈顶到栈底为1，2，3，4，5，也就是实现栈中元素的逆序，
* 但是只能用递归函数来实现，不能用其他数据结构。
* @author GPJ
*
*/
public class StackReverse {
public static int getAndRemoveLastElement(Stack<Integer> stack){
int result = stack.pop();
if(stack.isEmpty()){
return result;
}else{
int last = getAndRemoveLastElement(stack);
stack.push(result);
return last;
}
}
public static void reverse(Stack<Integer> stack){
if(stack.isEmpty()){
return;
}
int i = getAndRemoveLastElement(stack);
reverse(stack);
stack.push(i);
}
public static void main(String[] args) {
Stack<Integer> stack = new Stack<Integer>();
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
stack.push(5);
reverse(stack);
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
}
}答案的解法是对返回值进行操作，是通过递归获取到栈底元素，最后把该元素压栈
而我本人是把栈顶元素作为参数传到栈底，压栈。
扫一扫
584
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
