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

本文介绍了一种仅使用递归函数和栈操作实现栈逆序的方法。通过详细解析两种实现方案,包括使用辅助栈和单栈递归操作,展示了如何在不引入额外数据结构的情况下完成栈元素的逆序。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

/**

 * 如何仅用递归函数和栈操作逆序一个栈
 * 题目:
 * 一个栈依次压入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)这样的方法123的入栈出栈的过程,那么方法1在调用方法2的时候,方法2中的局部变量不受方法1的影响。那么可以实验一个最简单的例子进行测试实验。比如依次压栈123,此时的栈中元素如下:

 

此时把3弹栈,然后递归到2弹栈,再1弹栈,此时栈空,把3压栈,返回,再1压栈,再2压栈,3出栈-->2出栈-->1出栈-->3入栈-->1入栈-->2入栈,栈中元素就如下所示:

 

重复此过程就最终栈中元素变为如下形式:

 

很显然满足题目条件,那么基本思路有了,接下来开始完善细节,看是否存在可行性。

思路如下:

3出栈,2出栈,1出栈后,此时栈为空,因此开始递归返回,返回条件是栈空,此步可行。此时的栈中元素从栈顶到栈底依次为[213]

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

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

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

<think>我们正在编写一个递归函数来实现字符串的逆序输出。递归的基本思想是将问题分解为更小的子问题,直到达到一个基本情况(basecase),然后逐步返回并组合结果。对于字符串逆序输出,我们可以这样考虑:1.基本情况:如果字符串为空(长度为0)或者只有一个字符,那么直接返回该字符串(或者输出该字符)。2.递归步骤:将字符串分为第一个字符剩余部分。我们递归地对剩余部分进行逆序输出,然后在递归调用之后输出第一个字符。注意:递归函数在输出时,先递归处理剩余字符串,然后再输出当前字符,这样就能达到逆序的效果。根据引用[1]引用[2]中的C语言示例,我们可以总结出递归函数的框架:-如果当前字符是字符串结束符('\0')或者字符串长度为0,则直接返回(不输出任何内容或返回空)。-否则,先递归处理从下一个字符开始的子字符串,然后输出当前字符。下面我们分别用C语言Python来实现这个递归函数。一、C语言实现(参考引用[1][2]):在C语言中,我们可以使用指针来遍历字符串。递归函数的基本结构如下:voidreverse(char*s) {if(*s== '\0'){ //如果当前字符是字符串结束符,则返回return;}reverse(s+1);//递归处理下一个字符printf("%c",*s); //输出当前字符}但是注意,引用[1]中处理了长度为1的情况,但我们可以统一用当前字符是否为'\0'来判断。二、Python实现:在Python中,字符串是不可变的,我们可以使用切片来获取子字符串。递归函数可以这样写:def reverse_string(s):ifs =="":return""else:returnreverse_string(s[1:]) +s[0]但是,这个函数返回逆序后的字符串,而不是直接输出。如果我们希望直接输出,可以修改为:defreverse_print(s):ifs =="":returnreverse_print(s[1:])print(s[0],end='')然而,注意递归深度问题,对于长字符串可能引发递归深度限制(Python默认递归深度有限制)。另外,我们也可以返回字符串,这样更符合函数式编程的思想,而且可以避免递归深度问题(但递归深度问题仍然存在,对于长字符串可能不够用)。考虑到用户问题中没有指定语言,我们以C语言为例(因为引用中多为C语言),并补充Python版本。下面给出C语言Python的完整示例代码。C语言示例(参考引用[1]):#include<stdio.h>#include <string.h>void reverse(char *s){if (*s =='\0') {//基本情况:遇到字符串结束符return;}reverse(s +1); //递归调用,处理下一个字符printf("%c", *s);//输出当前字符}intmain(){char s[100];printf("请输入字符串:\n");scanf("%s", s);reverse(s);return0;}注意:这个程序使用递归,对于很长的字符串可能会导致溢出。Python示例(直接返回逆序字符串):defreverse_string(s):iflen(s) ==0:returnsreturn reverse_string(s[1:])+ s[0]#测试s= input("请输入字符串:")print(reverse_string(s))或者,如果我们希望直接输出而不返回字符串(模拟C语言的方式):defreverse_print(s):ifs =='':returnreverse_print(s[1:])print(s[0], end='')s= input("请输入字符串:")reverse_print(s)print()#最后换行但是,在Python中,递归深度有限制(可以通过sys.setrecursionlimit()设置,但不推荐),而且递归效率不高。因此,对于长字符串,建议使用迭代方法。根据用户的问题,他要求递归方法,所以我们提供递归的实现。总结:递归实现字符串逆序的核心思想是:先递归处理剩余字符串,再处理当前字符。注意事项:1.递归必须有终止条件,否则会无限递归导致溢出。2.对于空字符串的处理。相关问题:1.递归逆序输出字符串的时间复杂度空间复杂度是多少?2.递归方法在逆序字符串时有哪些局限性?3.如何用非递归(迭代)方法实现字符串逆序输出?4.递归逆序输出字符串在哪种编程语言中更高效?为什么?5.如何优化递归逆序输出字符串以避免溢出问题?</think>### 递归实现字符串逆序输出 下面我将详细解释递归实现字符串逆序的原理,并提供 C 语言 Python 两种实现方案: #### 递归原理 1. **基本思想**: 递归函数每次处理字符串的一个字符,通过不断缩小问题规模(向后移动指针),直到遇到终止条件(空字符或字符串结尾)。 递归调用后输出字符,形成"后进先出"的逆序效果。 2. **关键步骤**: - **递归步骤**:`reverse(str+1)` 处理下一个字符 - **输出步骤**:递归返回后输出当前字符 `*str` - **终止条件**:当遇到 `\0` 或字符串结尾时停止递归 3. **内存模型**: ```mermaid graph LR A[调用 reverse's'hello''] --> B[调用 reverse'ello''] B --> C[调用 reverse'llo''] C --> D[调用 reverse'lo''] D --> E[调用 reverse'o''] E --> F[输出 'o'] --> D D --> G[输出 'l'] --> C C --> H[输出 'e'] --> B B --> I[输出 'h'] --> A ``` #### C 语言实现 ```c #include <stdio.h> void reverse(char *str) { if (*str == '\0') return; // 终止条件:遇到空字符 reverse(str + 1); // 递归处理下一个字符 printf("%c", *str); // 输出当前字符(逆序核心) } int main() { char s[100]; printf("输入字符串: "); scanf("%s", s); reverse(s); return 0; } ``` **执行过程**(输入 "abc"): ``` 1. reverse("abc") → reverse("bc") → reverse("c") → reverse("") 返回 → 输出 'c' → 输出 'b' → 输出 'a' 输出结果: cba ``` #### Python 实现 ```python def reverse_print(s): if not s: return # 终止条件:空字符串 reverse_print(s[1:]) # 递归处理子串 print(s[0], end='') # 输出首字符 # 测试 reverse_print("abc") # 输出 cba ``` #### 关键说明 1. **递归深度**: 递归深度等于字符串长度 $n$,空间复杂度 $O(n)$(调用空间),时间复杂度 $O(n)$ 2. **终止条件**: - C 语言:检测空字符 `\0`(字符串结束符) - Python:检测空字符串 `""` 3. **输出时机**: 输出操作必须在递归调用**之后**执行,确保先处理尾部字符(核心逆序逻辑) > **注意**:递归方法不适合超长字符串(可能溢出),实际应用建议使用迭代法(如双指针交换)或语言内置函数(如 Python 的 `s[::-1]`)[^1][^2]。 --- ### 相关问题 1. 递归实现字符串逆序的空间复杂度是多少?如何优化? 2. 递归方法迭代方法在字符串逆序中有哪些性能差异? 3. 如果要求递归函数返回逆序字符串(而非直接打印),代码应如何修改? 4. 递归逆序输出在处理中文字符串时会有哪些特殊问题? 5. 如何用递归实现字符串的部分逆序(如前 n 个字符逆序)? [^1]: 递归思想实现逆序输出:反复调用函数直到找到最后一个字符,然后逐层输出该字符的前一个字符 [^2]: 递归的作用是每次读入一个字符,递归到最后一个字符后,从最后一次递归开始反向执行输出
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值