如何仅用递归函数和栈操作逆序一个栈

最新推荐文章于 2023-04-29 16:55:21 发布

蚂蚁要上天

最新推荐文章于 2023-04-29 16:55:21 发布

阅读量1.1k

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/gooaaee/article/details/80817230

版权

java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

/**

* 如何仅用递归函数和栈操作逆序一个栈
* 题目：
* 一个栈依次压入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());
	}
}

注释的代码表示我当时为了做标志变量，而产生死循环，由于SB 变量只是在第一次递归到栈底时需要，剩下递归就不需要该变量作为判断标志了。

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());
	}
}

答案的解法是对返回值进行操作，是通过递归获取到栈底元素，最后把该元素压栈

而我本人是把栈顶元素作为参数传到栈底，压栈。