递归

递归与尾递归 在计算机科学领域中,递归式通过递归函数来实现的。程序调用自身的编程技巧称为递归( recursion)。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法,它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解,递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算,大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。 一般来 阅读详情

递归

-递归就是方法里调用自身
-在使用递归策略时,必须有一个明确的递归结束条件,称为递归出口
-递归算法解题通常显得很简洁,但递归算法解题的运行效率较低
-在递归调用的过程中,系统为每一层的返回点、局部变量等开辟了栈来存储。递归次数过多容易造成栈溢出等
-具体地说,如果递归函数调用自己,则被调用的函数也将调用自己,这将无限循环下去,除非代码里有终止调用的语句。通常的方法是将递归调用放在if语句中。

递归例子:

  对递归最恰当的比喻,就是查词典。我们查词典的过程,本身就是递归。想象用一本纯英
文词典查单词,要查某一个单词的意思,翻到这个单词时,看解释,发现解释中有一个单 
词不认识,所以,无法明白这个要查的单词是什么意思;这时,再用这本词典(函数本
身) 查那个不认识的单词,又发现查的第2个单词的解释中又有一个单词不认识,那么,
又再用 这本词典查第3个不认识的单词,这样,一个一个查下去,直到解释中所有单词都
认识,这 样就到底了,就明白了最后一个单词是什么意思,然后一层一层倒回来,就知道
我最初想查 的第1个单词是什么意思了,问题就解决了。 
void function(arg1){
     statements1
     if(condition){  //condition为false,则终止调用,递归链断掉         
         function(arg2)
       }
      statements2
 } 

只要if语句为true,每个function()调用都将先执行statements1,然后再调用 function(),而不会执行statement2。当前调用结束后,程序控制权将返回给调用它的 function(),而该function()将继续执行statement2部分,然后结束,并将控制权返回给前 一个调用,以此类推。
在这里插入图片描述递归的3个主要的点:
(1)出口条件,即递归“什么时候结束”,这个通常在递归函数的开始就写好
(3)如何由"情况n" 变化到"情况n+1",也就是非出口情况,也就是一般情况 ——"正在"递归中的情况
(3)初始条件,也就是这个递归调用以什么样的初始条件开始

递归的基本思想 :

  是广义地把规模大的问题转化为规模小的相似的子问题或者相似的子问题集合来解决。
 广义针对规模的,规模的缩小具体可以是指递归函数的参数,也可以是其参数之一。相
 似是 指解决大问题的方法和解决小问题的方法往往是同一个方法,还可以是指解决子问
 题集的各 子问题的方法是同一个方法。解决大问题的方法可以是由解决次规模问题的方
 法和解决剩余 部分的方法组成,也可以是由一系列解决次规模问题的方法组成。 

递归的应用:

  1. 求和1+2+3+…+(n-1)+n
class Demo{
  public static void main(String[] args){
      int n=100;         
      int sum=getSum(n); 
              System.out.println(sum);
       }
       public static int getSum(int n){
            if(n==1){
                 return 1;
             }
             return getSum(n­1)+n; 
        }
 }

在这里插入图片描述
3. 斐波那契数列前20项:1,1,2,3,5,8,13,21…

class Demo{
    public static void main(String[] args){
      for(int i=1;i<=20;i++){
                     int num=fibo(i);
                      System.out.println(num);
         }
    }
    public static int fibo(int i){
      if(i==1||i==2){
            return 1;
       }
       return fibo(i­1)+fibo(i­2);                                                                                                                                                                                                                   
    }
 }

在这里插入图片描述
5. 求n的阶乘 n!

class Demo{
     public static void main(String[] args){
          int n=10;         
           int num=get(n);         
           System.out.println(num);     
      }     
      public static int get(int n){
        if(n==0||n==1){             
          return 1;         
        }         
        return get(n­1)*n;    
      } 
 } 
  1. 汉诺塔问题
    在这里插入图片描述
  2. 八皇后问题
    在这里插入图片描述
  3. 二叉搜索树
public class BinarySearchTree<E extends Comparable<E>> { // BST
	private class Node {
		public E e; // 节点数据域
		public Node left, right;
		public Node(E e) {
			this.e = e;
			left = null;
			right = null;
		}
	}
	private Node root; // 二分搜索树的根节点
	private int size;
	public BinarySearchTree() {
		root = null;
		size = 0;
	}
	// 获取树中元素的个数
	public int size() {
		return size;
	}
	// 判断树是否为空
	public boolean isEmpty() {
		return size() == 0;
	}
	// 将元素e添加到树中
	public void add(E e) {
		root = add(root, e);
	}
	// 以node为当前树的根节点,添加元素e并返回该树的根
	private Node add(Node node, E e) {
		if (node == null) {
			size++;
			return new Node(e);
		}
		if (e.compareTo(node.e) > 0) {
			node.right = add(node.right, e);
		} else if (e.compareTo(node.e) < 0) {
			node.left = add(node.left, e);
		}
		return node;
	}
	// 查找元素e是否存在于树中
	public boolean contains(E e) {
		// 迭代实现
		/*
		 * if(size()==0){ return false; } Node p=root; while(p!=null){
		 * if(e.compareTo(p.e)>0){ p=p.right; }else if(e.compareTo(p.e)<0){
		 * p=p.left; }else{ return true; } } return false;
		 */
		return contains(root, e);
	}
	// 查找以node为根节点的树是否包含元素e
	private boolean contains(Node node, E e) {
		if (node == null) {
			return false;
		}
		if (e.compareTo(node.e) > 0) {
			return contains(node.right, e);
		} else if (e.compareTo(node.e) < 0) {
			return contains(node.left, e);
		} else {
			return true;
		}
	}
	// 中序遍历 preOrder前序 postOrder后序
	public void inOrder() {
		ArrayList<E> list = new ArrayList<E>();
		inOrder(root, list);
		System.out.println(list);
	}
	private void inOrder(Node node, ArrayList<E> list) {
		if (node == null) {
			return;
		}
		inOrder(node.left, list);
		list.add(node.e);
		inOrder(node.right, list);
	}
	// 层序遍历 广度优先遍历
	public void levelOrder() {
		ArrayList<E> list = new ArrayList<E>();
		// 用辅助队列实现层序遍历
		Queue<Node> queue = new LinkedList<Node>();
		queue.add(root);
		while (!queue.isEmpty()) {
			Node cur = queue.poll();
			list.add(cur.e);
			if (cur.left != null) {
				queue.add(cur.left);
			}
			if (cur.right != null) {
				queue.add(cur.right);
			}
		}
		System.out.println(list);
	}
	@Override
	public String toString() {
		StringBuilder sb=new StringBuilder();
		generateBSTString(root,0,sb);
		return sb.toString();
	}
	private void generateBSTString(Node node, int level,
			StringBuilder sb) {
		if(node==null){
			sb.append(generateDepthString(level)+"null\n");
			return;
		}
		generateBSTString(node.left, level+1, sb);
		sb.append(generateDepthString(level)+node.e+"\n");
		generateBSTString(node.right, level+1, sb);
	}
	private String generateDepthString(int level) {
		StringBuilder sb=new StringBuilder();
		for(int i=0;i<level;i++){
			sb.append("--");
		}
		return sb.toString();
	}
	// 获取最小值
	public E minmum(){
		if(size()==0){
			throw new IllegalArgumentException("Tree is empty!");
		}
		return minmun(root).e;
	}
	// 以node为根节点 查找该树中的最小值
	private Node minmun(Node node){
		if(node.left==null){
			return node;
		}
		return minmun(node.left);
	}
	// 获取最大值
	public E maxmun(){
		if(size()==0){
			throw new IllegalArgumentException("Tree is empty!");
		}
		return maxmum(root).e;
	}
	private Node maxmum(Node node) {
		if(node.right==null){
			return node;
		}
		return maxmum(node.right);
	}
	// 删除最小值
	public E removeMin(){
		E e=minmum();
		root=removeMin(root);
		return e;
	}
	// 以node为根节点的二分搜索树,在删除最小值之后并返回新树的根
	private Node removeMin(Node node) {
		if(node.left==null){
			Node rightNode=node.right;
			node.right=null;
			size--;
			return rightNode;
		}
		node.left=removeMin(node.left);
		return node;
	}
	// 删除最大值
	public E removeMax(){
		E e=maxmun();
		root=removeMax(root);
		return e;
	}
	private Node removeMax(Node node){
		if(node.right==null){
			Node leftNode=node.left;
			node.left=null;
			size--;
			return leftNode;
		}
		node.right=removeMax(node.right);
		return node;
	}
	public void remove(E e){
		root=remove(root,e);
	}
	// 以node为根 删除指定元素e之后 返回新树的根
	private Node remove(Node node,E e){
		if(node==null){
			return null;
		}
		if(e.compareTo(node.e)>0){
			node.right=remove(node.right,e);
			return node;
		}else if(e.compareTo(node.e)<0){
			node.left=remove(node.left,e);
			return node;
		}else{
			if(node.left==null){
				Node rightNode=node.right;
				node.right=null;
				size--;
				return rightNode;
			}
			if(node.right==null){
				Node leftNode=node.left;
				node.left=null;
				size--;
				return leftNode;
			}
			Node successor=minmun(node.right);
			successor.right=removeMin(node.right);
			successor.left=node.left;
			node.left=node.right=null;
			return successor;
		}
	}
}

浅谈普通递归和尾递归 [举例(计算阶乘)] #include<stdio.h> /* 用尾递归思想计算阶乘 */ unsigned long Fact(unsigned int n, unsigned long a) { if(n == 0 || n == 1) { return a; } else { a = a * n; return Fact(n - 1, a); } } /* */ int main()... 阅读详情

相关推荐

如何实现SOLIDWORKS阵列的“智能变更”?

有时,我们在设计一个零件时,零件上有一排阵列孔,同时零件有不同的长度,我们又希望可以做到零件长度改变时,这排孔可以按长度等距增减孔阵列的个数;或是零件长度加长或缩短时,这排孔保持个数不变,按零件长度增减孔距。 那具体要怎么做呢?接下来,我们一起来看看怎么用SOLIDWORKS中简单的操作来实现这两种智能的变更: 零件长度加长或缩短时,这排孔要按长度等距增减孔阵列的个数。 零件长度加长或缩短时,这排孔保持个数不变,按零件长度增减孔距。 那接下来,我们一起来看看怎么用简单的操作来实现这两种智能的

SOLIDWORKS艾金米 2080

改别人Bug 系列《递归中使用Return 问题》

送人玫瑰,手留余香。回味一下余香,并总结记录。 项目场景: 语言: JS 框架: React 开发编辑器: VSCode 问题提出者:同事小G   问题描述 同事小G,想比较两个对象是否相同,他提供了代码发现return 退不出函数。 提供代码如下: // 判断对象是否相等 const isEqual = (obj1, obj2) => { if (Object.keys(obj1).length !== Object.keys(obj2).length) { retur.

星宇大前端 1926

分享一下使用Xilinx FPGA驱动MIPI DSI LCD屏的心路历程

分享一下调试用Xilinx FPGA驱动MIPI DSI LCD屏的心路历程,看到的朋友们,可以避免继续踩坑。

haoxingheng的专栏 5018

关于递归中return的理解(最浅显易懂)

递归中的return常用来作为递归终止的条件,但是对于返回数值的情况,要搞明白它是怎么返回的。递归的方式就是自己调用自己,而在有返回值的函数中,上一层的函数还没执行完就调用下一层,因此,当达到递归终止条件时,首先return的是最底层调用的函数,return之后,继续执行上一层调用该函数之后的代码,此时我们看到的是上一层的情况,当上一层剩余的代码执行完之后,表示上一层的函数也结束,此时再返回上上一...

Mr Liu的博客 2万+

SAP成本核算变式OKKN配置详解:从CK11N到CK24,手把手教你搞定标准成本发布

本文深入解析SAP成本核算变式OKKN的配置原理与实战应用,涵盖从CK11N到CK24的标准成本发布全流程。详细讲解数量结构控制、价值结构配置及间接费用计算规则,帮助成本会计精准掌握标准成本计算逻辑,解决BOM版本选择、工艺路线获取等常见问题,提升企业成本管理效率。

weixin_27219587的博客 292

【Dify精讲】第2章:后端服务架构深度剖析

Dify后端采用Flask应用工厂模式实现模块化开发,通过蓝图架构将API分为控制台、Web应用和服务接口三大模块。其设计亮点包括:1) 应用工厂模式支持多环境配置和独立测试;2) 蓝图分层管理实现API模块化,各模块职责清晰;3) 严格遵循RESTful原则设计API接口;4) 使用Flask-RESTful扩展简化API开发。这种架构既保持了Flask的灵活性,又实现了企业级应用的可维护性,是Flask项目架构的优秀实践案例。

wiyi9891的专栏 2128

return false的用法

在大多数情况下,为事件处理函数返回false,可以防止默认的事件行为。 例如,默认情况下点击一个<a>元素,页面会跳转到该元素href属性指定的页。 Return False 就相当于终止符,Return True 就相当于执行符。在js中return false的作用一般是用来取消默认动作的。比如你单击一个链接除了触发你的onclick事件(如果你指定的话)以外还要触发一个默认...

weixin_30606669的博客 362

AUTOSAR OS详细介绍及配置说明(更新版20240115)

AUTOSAR OS扩展了OSEK/VDX标准中的操作系统,所以本文结合OSEK/VDX的标准来介绍AUTOSAR OS,并借助Vector Configurator讲解AUTOSAR OS的配置。源于德语,英文意思是:“车载电子设备的开发系统和接口”,它是一个标准,用来产生嵌入式操作系统的规范,通讯协议栈,和汽车网络管理协议,也产生其他相关的规范。OSEK被设计来提供整车的各种电子控制单元的软件标准架构。

酒无忧的博客 1422

JS如何让递归后处理判断的时候为false就返回false,true就返回true?

今天在做LeetCode的 回文链表题时 发现了这个问题, 我在判断两个值不同的时候直接返回false, 但是递归在处理这个return false 是 跳过下面的语句,继续执行下一轮函数, 所以我当时人就傻了我先放代码 let cur; let checkList = ((head) => { if (head != null) { // 原来我是像下一行注解这么写的, 所以就遇到了那个问题 // checkList(head.next.

AzeShinja的博客 1320

【深度学习新浪潮】什么是system 1和system 2?

System 1(快速生成)指大模型直接基于输入生成响应,无需显式中间推理步骤。例如,GPT-4等模型在默认状态下通过Transformer直接输出结果,擅长快速回答简单问题或生成连贯文本,但在复杂逻辑任务中可能出错。这类模型的内部计算以向量形式隐式进行,难以处理符号推理等需要离散决策的任务。System 2(慢速推理)指模型通过生成中间token(如思维链、分步推导)或多次调用LLM进行复杂推理。

专注:太空算力、AI infra、异构调度、大模型成本工程 932

Unity Sprite Atlas C++底层原理全解析 —— “像素聚合工厂”的秘密

Unity Sprite Atlas C++底层实现简析 Sprite Atlas是Unity中用于优化2D渲染性能的核心机制,其C++底层实现如同一个高效的"像素聚合工厂"。该系统通过将多个小纹理合并为一个大纹理,显著减少Draw Call次数和GPU纹理切换开销。 在数据结构上,底层采用SpriteAtlasData存储图集元数据,PackedTexture管理合并后的大纹理,SpriteFrame记录每个子精灵的位置信息,并通过哈希表实现快速查找。编辑器阶段使用最大矩形等算法优化空

本博客聚焦游戏开发技巧、创业实战心得及大学热门课程干货。这里既有技术深度,也有思维广度,无论你是开发者、创业者还是高校学子,都能在这里找到适合自己的成长之路! 206

递归中使用return,未达到预期的结束

private FolderNode updateUnitFolderNodeCache(List<obj> nodes, String rootId) { for (obj o : nodes) { if (rootId.equals(o.id)) { **return o;** 退出了递归的当前的一层而已 } else { List<obj> c...

qq_40815137的博客 1951

手把手教您解决 AdGuard Home DNS重写功能失效的问题

AdGuard Home 设置了 DNS 重写,规则明明没问题,客户端却死活解析不到内网 IP?🤯 别急着重装!🚫 本文手把手教你如何解决软路由 DNS 解析“玄学”故障!🛠️🚀

XiaoqiangClub的博客 931

递归详解——让你真正明白递归的含义

让天下没有难学的程序(只有秃头的程序员 2333),学会程序和算法,走遍天下都不怕! 今天呢我们来讲一下非常有用也非常令人费解的算法——递归! Oh my god 可能很多人在大一的时候,就已经接触了递归了,不过,我敢保证很多人初学者刚开始接触递归的时候,是一脸懵逼的,我当初也是,..

青春无问西东 岁月自成芳华 12万+

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Ackerman的递归与非递归算法

已知Ackerman函数的定义如下: akm(m,n)=⎧⎩⎨n+1,akm(m−1,1),akm(m−1,akm(m,n−1)),m = 0m≠0,n=0m≠0,n≠0akm(m,n)= \begin{cases} n+1, & \text{m = 0} \\ akm(m-1,1),& m \neq 0, \, n = 0 \\ akm(m-1,akm(m,n-1)),& m \ne

sanqima的专栏 1万+

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

将递归函数转换为非递归形式

任何递归函数转换为非递归函数有一套固定的规则,使用该规则可以将任何递归函数转换为非递归函数。

sunny_ss12的专栏 1万+

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

【算法】递归:递归优化之尾递归

文章首先会先通过斐波那契数列来复习在以往介绍的解决递归的方法,然后在通过这个例子去分析递归法的不足之处,最后将会介绍一下关于递归的优化策略,并举例实现。

qq_66725576的博客 4968

递归算法与非递归算法比较

转载自:https://blog.youkuaiyun.com/mhsszm/article/details/78445591 非递归效率高;递归代码写出来思路清晰,可读性强。 生成可执行文件大小应该和编译器有关吧。。。。 递归的话函数调用是有开销的,而且递归的次数受堆栈大小的限制。 以二叉树搜索为例: bool search(btree* p, int v) { if (null ...

u013073067的博客 1万+

递归与间接递归

1. 介绍 递归技术允许我们将原问题分解为一个或多个形式上相似的子问题   2. 例子:级数 级数(n!)的定义如下:    n! = 1 * 2 * 3 * .... * (n-2) * (n-1) * n 可以根据定义写出如下迭代形式的实现 int fact(int n) {    int i;    int result;       result = ...

java的天空 4494

递归?何为递归

递归算法是一种直接或间接地调用自身的算法。在计算机编写程序中,递归算法对解决一大类问题是十分有效的,它往往使算法的描述简洁而且易于理解.   递归的分类:     递归分为两种,直接递归和间接递归。     直接递归称为方法自身调用自己。     间接递归可以A方法调用B方法,B方法调用C方法,C方法调用A方法。     for循环实现99乘法表 public class test99 { public static void main( String[] args ) { ...

u012343977的博客 1789

对递归的理解以及怎么写递归程序

1.一定要搞清楚当前你的递归程序的功能是什么,以及需不需要返回值,如果需要,则返回的值是什么,如果对当前递归程序要完成的功能模棱两可、一知半解,那么逻辑肯定混乱,也就不容易写出正确的递归程序。 2.找递归终止条件,根据函数的参数来看,看参数怎么样的时候是到了递归出口,注意:这种递归终止情况是由:1.这个递归程序解决的就是一个终止条件,比如斐波那契就是为了算n=1或者2。2这个终止情况是由上...

xiaohuihui1994的博客 6455

递归 递归 递归 —深入浅出

递归是种思想,不是算法。一个算法,你用递归去实现,它就是递归算法;你用循环去实现,它就是非递归算法。递归与循环一一对应,大多数编程语言都支持循环,但不一定支持递归。一个大问题,分解成类似的小问题,递归只用一句话就能描述这些“重复工作”,代码那叫一个简单!想想这句话的威力都觉得很牛B!递归算法简单而又经典的例子有:n!、Fibonacci、Hanoi、回溯、树遍历、图搜索。敲代码的时候,

小北的家 6784

递归与非递归

一、什么是递归很多数据结构的定义都是根据递归性质来进行定义的,是因为这些结构固有的性质。递归是指某个函数直接或间接的调用自身。问题的求解过程就是划分成许多相同性质的子问题的求解,而小问题的求解过程可以很容易的求出,这些子问题的解就构成里原问题的解了。二、递归的几个特点1.递归式,就是如何将原问题划分成子问题。2.递归出口,递归终止的条件,即最小子问题的求解,可以允许多个出口。3.界函数,问

ldong2007的专栏 2270

递归——线性递归与二分递归

递归线性递归例子1:数组求和int sum( int A[], int n) { //数组求和算法:线性递归版 if ( 1 &gt; n ) //平凡情况,递归基 return 0; //直接计算 else //一般情况 return sum(A, n-1) + A[n - 1]; //递归:前n-1项之和,再累计第n-1项 }每一递归实例对自身的调用至多一次。于是,每...

amoscykl的博客 5045

什么是递归?递归有哪些常见应用?

选择递归还是迭代应根据具体问题的需求和资源限制来决定。如果问题可以分解为多个相似子问题,且注重代码的简洁性和可读性,递归可能是更好的选择。然而,在追求高效运行和处理大量数据时,迭代通常更为适用。

破损的天堂鸟博客 1984

递归算法和尾递归

递归算法和尾递归

Charge8的博客 1709
上一篇: 数据结构---树
下一篇: 数据结构---集合与映射
inferno devil
博客等级 码龄9年 54粉丝 172原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值