递归,冒泡,阶乘的介绍

递归,冒泡,阶乘 的介绍

一、递归


  1. 什么是递归?

自身方法的调用,叫递归

2.  递归的特点?

(1)递归方法一直会调用自己直到某些条件被满足

(2)递归方法可有参数,而它会把一些新的参数值传递给自己


案例1:0, 1, 1, 2, 3, 5, 8.............30

        第一种递归呈现效果
        
        static void Main(string[] args)  
       ...{  
 
            int[] num=new int[30];  
            num[0]=1;  
            num[1]=1;  
            int first=num[0];  
            int second=num[1];  
         for (int i = 2; i < num.Length; i++)  
            ...{  
             num[i] = first + second;  
             first = second;  
             second = num[i];  
            }  
            Console.WriteLine(num[29]);  
            Console.ReadLine();  
 }  

           第二种递归呈现效果 
           
           //Main方法
            static void Main(string[] args)  
                 ...{  
            Console.WriteLine(Process1(30));  
            Console.ReadLine();   
             }  
             
        //用于计算值的方法
        public static int Process1(int i)  
        ...{  
           if (i == 0) return 0;  
           if (i == 1) return 1;  
           else 
           return Process1(i - 1) + Process1(i - 2);  
        }  
           
     在Main方法中,调用这Fib方法进行测试,你会发现和上面实现的效果一样 !但是使用到递归性能要比第一种方法差

练习的题目:求 1 -2 +3 +-4+ 5- 6 + 7 - 8 + 9  的值

二 、 冒泡

  1. 什么是冒泡排序?

每一次排序的过程中总有一个最大的值被移动到后面,值小的就像水泡一样浮到水面。

2.  冒泡排序的特点?

常用于比较

案例:对3,1, 4, 2, 5 ,7 进行由小到大进行排序,比较

                int[] a={3,1,4,2,5};
                int length=a.length;
            for (int i = 0; i < length; i++) {
                     for (int j = 1; j < length-i; j++) {
                     if(a[j-1]>a[j]){
                     int temp=a[j];
                     a[j]=a[j-1];
                      a[j-1]=temp;
             }
         }
}
        for (int i = 0; i < a.length; i++) {
             System.out.println(a[i]);
}

练习的题目:将下这7个数由小到大排序

2, 4, 6, 7,9, 10,8

三、 阶乘

  1. 什么是阶乘?

求数的乘积

  1. 阶乘的算法?

    如: 求5的阶乘

    5!=5 * 4 * 3 * 2 * 1

案例:

                public int digui(int i) {
                     if(i>1){
                      return i*digui(i-1);
             }else{
                          return i;
             }
        }
            System.out.println("求5的阶乘:"+digui(5));

练习的题目: 求36的阶乘

36!=1*2*3*……*34*35*36

时间: 2024-08-15 16:12:50

递归,冒泡,阶乘的介绍的相关文章

利用递归求阶乘

1 package com.d; 2 3 import java.util.Scanner; 4 5 public class Digui { 6 7 public static void main(String[] args) { 8 Digui d = new Digui(); 9 10 System.out.println("请输入一个整数"); 11 Scanner scan = new Scanner(System.in); 12 int a = scan.nextInt()

递归实现阶乘

如果想实现一个阶乘,比如6 * 5 * 4 * 3 * 2 * 1,首先想到的可能是循环遍历.如下: class Program { static void Main(string[] args) { Console.WriteLine("请输入一个数"); int number = Convert.ToInt32(Console.ReadLine()); double result = JieCheng(number); Console.WriteLine(number.ToStri

[Lua学习]递归求阶乘

1 --递归求阶乘 2 function func(n) 3 if n ~= 1 then 4 return n * func(n - 1) 5 else 6 return 1 7 end 8 end 9 10 print("输入整数:") 11 a = io.read("*number") 12 print(a .. "! -> " .. func(a)) ps:函数内也可以用(a and b) or c 这种形式的语句替代(未亲测).

递归求阶乘和

6-2 递归求阶乘和 (10 分) 本题要求实现一个计算非负整数阶乘的简单函数,并利用该函数求 1!+2!+3!+...+n! 的值. 函数接口定义: double fact( int n ); double factsum( int n ); 函数fact应返回n的阶乘,建议用递归实现.函数factsum应返回 1!+2!+...+n! 的值.题目保证输入输出在双精度范围内. 裁判测试程序样例: include <stdio.h> double fact( int n ); double f

Java50道经典习题-程序22 递归求阶乘

题目:利用递归方法求5!.分析:递归公式:n*factorial(n-1); 1 public class Prog22 { 2 public static void main(String[] args) { 3 System.out.println(factorial(5)); 4 } 5 //递归求阶乘 6 public static long factorial(int n) { 7 if(n==0||n==1) { 8 return 1L; 9 } 10 return n*factor

java例题_22 用递归求阶乘 5!

1 /*22 [程序 22 递归求阶乘] 2 题目:利用递归方法求 5!. 3 程序分析:递归公式:fn!=fn*4! 4 */ 5 6 /*分析 7 * 递归:如果其中每一步都要用到前一步或前几步的结果,称为递归的 8 * 根据提示,可以用算法x!=x*(x-1)!;y=x-1,y!=y*(y-1)!;... 9 * 10 * */ 11 12 13 package homework; 14 15 public class _22 { 16 17 public static void main

循环和递归写阶乘

/* 循环写阶乘 */ 4 5 #include<stdio.h> 6 int main() 7 { 8 int sum = 1; 9 int i; 10 for (i = 1; i < 100;i++) 11 { 12 sum *= i; 13 } 14 printf("%d", sum); 15 16 17 return 0; 18 } 1 /* 2 递归写阶乘 3 */ 4 5 #include<stdio.h> 6 int mult(int num

Java 递归、尾递归、非递归 处理阶乘问题

n!=n*(n-1)! import java.io.BufferedReader; import java.io.InputStreamReader; /** * n的阶乘,即n! (n*(n-1)*(n-2)*...1). * 0!为什么=1,由于1!=1*0!.所以0!=1 * * @author stone * @date 2015-1-6 下午18:48:00 */ public class FactorialRecursion { static long fact(long n) {

递归:阶乘、斐波那契数列

阶乘 public static void main(String[] args) { System.out.println(factorial(5));; } //factorial 阶乘 public static long factorial(int n) { if (n == 1) { return 1; } return n*factorial(n-1); } 阶乘画图理解 斐波那契数列递归实现: public static void main(String[] args) { Sys