精华内容
下载资源
问答
  • 正规的对称式杨辉三角(经典递归算法) 正规的对称式杨辉三角(经典递归算法) 正规的对称式杨辉三角(经典递归算法) 正规的对称式杨辉三角(经典递归算法) 正规的对称式杨辉三角(经典递归算法) 有助于初学者...
  • java实现的经典递归算法三例 十分的经典,可以学习一下
  • Java经典递归算法

    万次阅读 多人点赞 2018-06-16 23:17:57
    // 对中间索引左边的数组进行递归 sort(data, left, center); // 对中间索引右边的数组进行递归 sort(data, center + 1, right); // 合并 merge(data, left, center, right); } } public ...

    1.斐波那契数列

    package com.luna.base;
    public class BirthRabbit {
    	public static void main(String[] args) {
    		int i = 1;
    		for (i = 1; i <= 20; i++) {
    			System.out.println("兔子第" + i + "个月的总数为:" + f(i));
    		}
    	}
    	public static int f(int x) {
    		if (x == 1 || x == 2) {
    			return 1;
    		} else {
    			return f(x - 1) + f(x - 2);
    		}
    	}
    }

    2.从1到100相加

    package com.luna.base;
    public class Plus {
    	public int sum(int i) {
    		if (i == 1) {
    			return 1;
    		}
    		return i + sum(i - 1);
    	}
    	public static void main(String[] args) {
    		Plus plus = new Plus();
    		System.out.println("计算结果:" + plus.sum(100) + "!");
    	}
    }

    3.100的阶乘

    package com.luna.base;
    import java.math.BigInteger;
    public class LoopMutiply {
    	public BigInteger sum(int i) {
    		if (i == 1) {
    			return BigInteger.ONE;
    		}
    		return BigInteger.valueOf(i).multiply(sum(i - 1));
    	}
    	public static void main(String[] args) {
    		LoopMutiply test = new LoopMutiply();
    		try {
    			System.out.println("计算结果:" + test.sum(50) + "!");
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }

    4.有序数组a、b合并成一个新的有序数组

    package com.luna.base;
    public class ArraySort {
    	public static void main(String[] args) {
    		int[] a = { 1, 3, 4 };
    		int[] b = { 2, 3, 5, 6 };
    		int[] c = mergeArray(a, b);
    		for (int n : c) {
    			System.out.print(n + " ");
    		}
    	}
    	// 合并数组
    	public static int[] mergeArray(int[] a, int[] b) {
    		int result[] = new int[a.length + b.length];
    		if (checkSort(a) && checkSort(b)) {
    			// 说明ab数组都是有序的数组
    			// 定义两个游标
    			int i = 0, j = 0, k = 0;
    			while (i < a.length && j < b.length) {
    				if (a[i] <= b[j]) {
    					result[k++] = a[i++];
    				} else {
    					result[k++] = b[j++];
    				}
    			}
    			while (i < a.length) {
    				// 说明a数组还有剩余
    				result[k++] = a[i++];
    			}
    			while (j < b.length) {
    				result[k++] = b[j++];
    			}
    		}
    		return result;
    	}
    	// 检查一个数组是否是有序1 2 3
    	public static boolean checkSort(int[] a) {
    		boolean flag = false;// 默认不是有序的
    		for (int i = 0; i < a.length - 1; i++) {
    			if (a[i] > a[i + 1]) {
    				// 说明不是有序的
    				flag = false;
    				break;
    			} else {
    				flag = true;
    			}
    		}
    		return flag;
    	}
    }

    5.归并排序算法实现

    package com.luna.base;
    public class MergingSort {    
        public static void sort(int[] data, int left, int right) {    
            if (left < right) {    
                // 首先找出中间的索引    
                int center = (left + right) / 2;    
        
                // 对中间索引左边的数组进行递归    
                sort(data, left, center);    
        
                // 对中间索引右边的数组进行递归    
                sort(data, center + 1, right);    
                // 合并    
                merge(data, left, center, right);    
            }    
        }    
        
        public static void merge(int[] data, int left, int center, int right) {    
            int[] tmpArr = new int[data.length];        
            int mid = center + 1;      
            // third记录中间数组的索引    
            int third = left;    
            int tmp = left;        
            while (left <= center && mid <= right) {    
                // 将两个数组中取出最小的数放入中间数组    
                if (data[left] <= data[mid]) {    
                    tmpArr[third++] = data[left++];    
                } else {    
                    tmpArr[third++] = data[mid++];    
                }    
            }    
        
            // 剩余部分依次放入中间数组    
            while (mid <= right) {    
                tmpArr[third++] = data[mid++];    
            }       
            while (left <= center) {    
                tmpArr[third++] = data[left++];    
            }                
            while(tmp <= right){    
                data[tmp] = tmpArr[tmp++];    
            }    
        }    
        
        public static void main(String[] args) {    
            int[] a = { 3, 2, 5, 4 };               
            sort(a, 0, a.length - 1);        
            for (int i = 0; i < a.length; i++) {    
                System.out.print(a[i] + " ");    
            }    
        }    
    }    
             更多排序算法的实现,请进传送门→

    原文地址: https://blog.csdn.net/u011635492/article/details/80715832
    展开全文
  • 用java实现的经典递归算法.doc
  • hanoi塔经典递归算法

    千次阅读 2017-07-24 21:05:50
    这里用到了递归的手法 :假设有n片,移动次数是f(n).显然f(1)=1,f(2)=3,f(3)=7,且f(k+1)=2*f(k)+1。此后不难证明f(n)=2^n-1。n=64时, 假如每秒钟一次,共需多长时间呢?一个平年365天有31536000 秒,闰年366天...

    法国数学家爱德华·卢卡斯曾编写过一个印度的古老传说:在世界中心贝拿勒斯(在印度北部)的圣庙里,一块黄铜板上插着三根宝石针。印度教的主神梵天在创造世界的时候,在其中一根针上从下到上地穿好了由大到小的64片金片,这就是所谓的汉诺塔。不论白天黑夜,总有一个僧侣在按照下面的法则移动这些金片:一次只移动一片,不管在哪根针上,小片必须在大片上面。僧侣们预言,当所有的金片都从梵天穿好的那根针上移到另外一根针上时,世界就将在一声霹雳中消灭,而梵塔、庙宇和众生也都将同归于尽。

    额额额额~~~~

    传说有点可怕,但还是想知道多长时间可以完成任务~~~~

    这里用到了递归的手法 :假设有n片,移动次数是f(n).显然f(1)=1,f(2)=3,f(3)=7,且f(k+1)=2*f(k)+1。此后不难证明f(n)=2^n-1。n=64时,

    假如每秒钟一次,共需多长时间呢?一个平年365天有31536000 秒,闰年366天有31622400秒,平均每年31556952秒,计算一下:

    18446744073709551615秒

    这表明移完这些金片需要5845.54亿年以上,而地球存在至今不过45亿年,太阳系的预期寿命据说也就是数百亿年。真的过了5845.54亿年,不说太阳系和银河系,至少地球上的一切生命,连同梵塔、庙宇等,都早已经灰飞烟灭。

    好了,娱乐结束,回到正题:

    题意很简单,三个柱子,最左边柱子上有n个盘子(也有叫碟子的),要求把盘子都移动到最右边的柱子上,移动规则如下:

     

    1. 每次只能从一个柱子的最上面移动一个碟子到另外一个柱子上。

    2. 不能将大碟子放到小碟子的上面。

    假设只有一个盘子,直接把它移到C柱子上;

    两个盘子,先把第一个移到B上,然后把第二个移到C上,最后把第一个移到C上;

    三个盘子,先把前两个移到B上,然后把最后一个移到C上,最后把前两个移到C上;

    ......

    n个盘子,先把前n-1个移到B上,然后把最后一个移到C上,最后把前n-1个移到C上;

    所以每次需要三大步就可以完成,很简单吧;

    BUT~~~代码呢???

    别着急,自己先尝试敲一遍;

     

     

    代码奉上

        #include <bits/stdc++.h>
        int count=0;      //用来计步;
        void hanoi(int n, char A, char B, char C)  //n为盘子的个数,A是最左边柱子,C是最右边柱子,B是中间柱子;
        {
            if(n==1){
                printf("The %d step : %c -> %c\n",++count,A,C);  //只有一个盘子,直接从A移动到C;
                return;
            }
            hanoi(n-1, A, C, B);             //n-1个盘子,把前n-1个移动到B柱子,最后一个移动到C柱子,再把n-1个从B移动到C;
            printf("The %d step : %c -> %c\n",++count,A,C);
            hanoi(n-1, B, A, C);             //第n个盘子移完后,从B上把n-1个移到C上;
        }
        int main()
        {
            int n;
            scanf("%d",&n);
            hanoi(n, 'A', 'B', 'C');
            return 0;
        }

     

     

    展开全文
  • 汉诺塔 经典递归算法 in python

    千次阅读 2015-03-25 14:00:56
    递归算法,把大规模问题分解成容易解决而且求解方法相同的子问题,一般用递归函数实现,递归函数就是不断调用自身的函数。   举个例子:     俄罗斯套娃(应该都玩过,里面最小的那个不能打开,其他...

        递归算法,把大规模问题分解成容易解决而且求解方法相同的子问题,一般用递归函数实现,递归函数就是不断调用自身的函数。

        举个例子:

               

          俄罗斯套娃(应该都玩过,里面最小的那个不能打开,其他能打开。从最小的娃娃开始,用稍大的那个娃娃套着,直至最大的一个套住所有的娃娃)。

         现在有如图俄罗斯套娃,已经按正确的方法套好,里面最小的那个娃娃背上写了一个密码。现在需要求解的问题是得到那个密码,并且得到密码后要把这套俄罗斯娃娃按正确的方法套好。

          那么做法应该是,一层一层地打开娃娃,直到看到最小的娃娃之后获取密码,然后一个一个的把娃娃合上。也就是,分别按顺序对每一个娃娃进行打开的操作,直至打开到小娃娃,查看密码,然后再进行依次闭合娃娃的操作。

          这就是一个递归过程。而这个递归函数就是打开闭合娃娃,判断里面的娃娃是否是最小的那个,如果是,获取密码,如果不是,打开下一个娃娃,并且最后关闭当前娃娃。

         

    伪代码如下:

    # 娃娃编号从小到大依次递增,为1~5
    def getKey ( n ) :
    	if n == 1 :   # 判断当前娃娃是不是最小的那个娃娃
    		读取密码   #进行操作
    	else :
    		getKey(n-1)   # 对当前娃娃套住的娃娃进行相同的操作 
    		关闭娃娃      <span style="font-family: Arial, Helvetica, sans-serif;">#进行操作</span>


    一个问题能否用递归求解,要看这个问题能不能逐层分解成一个个规模依次变小的小问题,同时有能够进行判断的下限(就是不能再小的子问题)。


    而确定能够用递归过程求解之后,关于求解步骤,可以直接分析最小的子问题跟比最小子问题“大1”的子问题。还需要知道的有:最小子问题的判断依据以及处理步骤、如何递归调用自身。

           拿汉诺塔问题举例:(借助B柱,将A柱上的n块盘子移动到C柱)

           最小的子问题就是:将一块盘子从A移动到C柱

    “大1”的子问题是:将两块盘子从A移动到C柱,不妨在草稿纸上画个图,显然有三个步骤:

    1.将最上面的盘子从A移动到B

    2.将A下面的盘子从A移动到C

    3.将B上的盘子移动到C

    而程序调用自身则是逐次对(n-1)个盘子进行同样的操作就可以解决n个盘子移动的问题。

    只需以上三步分析就能得到这个递归程序的全部求解过程。


    汉诺塔代码如下:

    n = int(input("输入初始化时A塔上盘子的个数n:\n"))
    def move( n , A , B ,C ):   
    	if n == 1 :       
    		print( "%s is moved to %s" %(A ,C) )
    	else :
    		move( n-1 , A , C , B )   
    		move( 1 , A , B , C )
    		move( 1 , B , A , C )
    move( n ,'A' , 'B' , 'C')	


    如果还是不理解的话,自己动手写一个递归程序最能加深理解。经典的递归问题有:Fibonacci数列、扫雷小游戏。    

    题外话:传说古老印度在一个圣庙里,一块黄铜板上插着三根宝石针。印度教的主神梵天在创造世界的时候,在其中一根针上从下到上地穿好了由大到小的64片金片圣庙,一块黄铜板上插着三根宝石针。印度教的主神梵天在创造世界的时候,在其中一根针上从下到上地穿好了由大到小的64片金片。不论白天黑夜,总有一个僧侣在按照下面的法则移动这些金片,一次只移动一片,不管在哪根针上,小片必在大片上面。当所有的金片都从梵天穿好的那根针上移到另外一概针上时,世界就将在一声霹雳中消灭,梵塔、庙宇和众生都将同归于尽。

        n个盘子最少需要移动2^n-1,如果一秒钟移动一次,计算出来需要5800多亿年,那时候,地球还存在吗?这样看来,这个毁灭论倒是有一定道理的啊。

    展开全文
  • .net 递归算法.net 递归算法.net 递归算法.net 递归算法.net 递归算法.net 递归算法.net 递归算法.net 递归算法
  • 递归算法详解递归算法详解递归算法详解递归算法详解
  • 18.递归算法递归算法应用.ppt
  • 递归算法经典递归例子

    万次阅读 2018-06-28 18:52:55
    一、什么叫递归 递归函数就是直接或间接调用自身的函数,也就是自身调用自己。二、一般什么时候使用递归? 递归是常用的编程技术,其基本思想就是“自己调用自己”,一个使用递归技术的方法即是直接或间接的调用...

    一、什么叫递归

      递归函数就是直接或间接调用自身的函数,也就是自身调用自己。

    二、一般什么时候使用递归?

      递归是常用的编程技术,其基本思想就是“自己调用自己”,一个使用递归技术的方法即是直接或间接的调用自身的方法。递归方法实际上体现了“以此类推”、“用同样的步骤重复”这样的思想。

        还有些数据结构如二叉树,结构本身固有递归特性;此外,有一类问题,其本身没有明显的递归结构,但用递归程序求解比其他方法更容易编写程序。

    三、经典递归算法

     1、递归阶乘n! = n * (n-1) * (n-2) * ...* 1(n>0)

    public static Integer recursionMulity(Integer n){
       if(n==1){
          return 1;
       }
       return n*recursionMulity(n-1);
    }

    2、汉诺塔问题

    public static void hanio(int n,char a,char b,char c){
     8         if(n==1)
     9             System.out.println("移动"+n+"号盘子从"+a+"到"+c);
    10         else{
    11             hanio(n-1,a,c,b);//把上面n-1个盘子从a借助b搬到c
    12             System.out.println("移动"+n+"号盘子从"+a+"到"+c);//紧接着直接把n搬动c
    13             hanio(n-1,b,a,c);//再把b上的n-1个盘子借助a搬到c
    14         }
    15     }
    

    3.判定一系列字符串中是否有相同的内容

    public class Crf{
        public static void main(String[] args) {
            String[] a = {"a1","a2","a3","b3","c","b","33","33"};
            fun(0, a);
        }
        
        public static void fun(int n,String[] a){
            	for(int i = n; i < a.length-1; i++){
                    System.out.println(n+"    "+(i+1));
                    if(a[n].equals(a[i+1])){
                    	System.out.println("存在相同字符");    
                    	System.out.println(a[n]);    
                    }
                }
            n++;
            fun(n,a);
        }
    }



    展开全文
  • 递归算法转为非递归算法。方法、过程,用栈的原理
  • 一 、递归算法简介 在数学与计算机科学中,递归是指在函数的定义中使用函数自身的方法。  递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中,递归算法对解决一大类问题是十分有效的,它往往使...
  • 5!递归算法和非递归算法,面试专用,适合新手
  • 递归算法转换为非递归算法

    千次阅读 2019-04-24 17:40:07
    对于某些复杂问题(例如hanio塔问题),递归算法是一种自然且合乎逻辑的解决问题的方式,但是递归算法的执行效率通常比较差。因此,在求解某些问题时,常采用递归算法来分析问题,用非递归算法来求解问题...
  • Java递归算法

    2020-12-22 17:40:01
    递归算法是一种直接或者间接调用自身函数或者方法的算法。Java递归算法是基于Java语言实现的递归算法。  递归算法的实质是把问题分解成规模缩小的同类问题的子问题,然后递归调用方法来表示问题的解。递归算法对...
  • 递归算法到非递归算法的转换,递归算法到非递归算法的转换。
  • 递归算法向非递归算法转换

    千次阅读 2013-06-10 22:18:04
    递归算法实际上是一种分而治之的方法,它把复杂问题分解为简单问题来求解。对于某些复杂问题(例如hanio塔问题),递归算法是一种自然且合乎逻辑的解决问题的方式,但是递归算法的执行效率通常比较差。因此,在求解...
  • 递归算法经典递归例子代码实现

    万次阅读 多人点赞 2017-03-24 17:28:19
    一、什么叫做递归? 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法; 递归函数就是直接或间接调用自身的函数,也就是自身调用自己; 二、一般什么时候使用递归?  递归时常用的编程技术,...
  • 递归算法讲解

    万次阅读 多人点赞 2017-06-15 22:11:51
    原作者:书呆子Rico 《递归的内涵与经典应用》 http://my.csdn.net/justloveyou_摘要: 大师 L. Peter Deutsch 说过:To Iterate is Human, to Recurse, Divine.中文译为:人理解迭代,神理解递归。毋庸置疑地,...
  • Python汉诺塔算法(经典递归)

    万次阅读 2017-11-17 16:56:21
    经典递归算法——汉诺塔
  • 经典算法详解 之 递归算法

    千次阅读 多人点赞 2012-04-03 18:12:59
    递归算法递归算法是把问题转化为规模缩小了的同类问题的子问题。然后递归调用函数(或过程)来表示问题的解。
  • 递归算法

    千次阅读 2016-09-02 12:53:34
    递归算法的定义:递归过程一般通过函数或子过程来实现 递归算法解决问题的特点: (1) 递归就是在过程或函数里调用自身。 (2) 在使用递归策略时,必须有一个明确的递归结束条件,称为递归出口。 (3) 递归算法解题...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 480,647
精华内容 192,258
关键字:

经典递归算法