冒泡排序和递归

冒泡排序

什么是冒泡排序: 数组当中相邻的两个数进行比较，数组当中比较小的数值向下沉，数值比较大的向上浮！外层for循环控制循环次数，内层for循环控制相邻的两个元素进行比较。

冒泡排序算法的原理如下：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

针对所有的元素重复以上的步骤，除了最后一个，直到没有任何一对数字需要比比较

    // 实现冒泡
    var arr = [29,45,51,68,72,97];
    //外层循环，控制趟数，每一次找到一个最大值
    for (var i = 0; i < arr.length - 1; i++) {
        // 内层循环,控制比较的次数，并且判断两个数的大小
        for (var j = 0; j < arr.length - 1 - i; j++) {
            // 白话解释：如果前面的数大，放到后面(当然是从小到大的冒泡排序)
            if (arr[j] > arr[j + 1]) {
                var temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
 
    }
    console.log(arr);//[2, 4, 5, 12, 31, 32, 45, 52, 78, 89]

逻辑题

1.中国有一套反导系统，某国向中国发射N枚导弹，导弹系统有一个bug，10000米导弹飞过来，射下来，发射过来
[10000,5888,12000,6999,7000,3000,4500,1200,6000],需要多少个反导系统可以全部拦截下来。

// let index = null; //要存入的次数
    // let arr = [10000, 5888,3800,6000,7654,568,445,6680,500,4030,10008,6900,]; //导弹数组
    // for (let i = 0; i < arr.length; i++) {//第一遍循环对比
    //   let db = arr[i];
    //   for (let j = 1; j < arr.length; j++) {
    //     if (db > arr[j]) {//变量进行对比 高度数组进行对换
    //       db = arr[j]; //换位
    //       arr.splice(j, 1); //不符合的次数截取
    //     }
    //     console.log(i);
    //     index = i + 1; //计算
    //   }
    // }
    // console.log(index);

冒泡优点： 简单,好上手
缺点：效率不高

递归调用

递归的概念

1、递归就是方法自己调用自己,每次调用时传入不同的变量。

2、递归有助于解决复杂的问题，同时可以让代码变得简洁。

递归的作用

1. 替代多重循环：比如回溯法中有用到递归来做。

2. 解决本身就是用递归形式定义的问题

3. 将问题分解为规模更小的子问题进行求解

递归就是一个函数调用其本身。

例，求n!

    int factorial(int n){
        if(n==1) return 1;
        return n*factorial(n-1);
    }

执行过程，比如求factorial(5)

1.  fac(5) = 5 * fac(4)，求fac(4)

2.  fac(4) = 4 * fac(3)，求fac(3)

3.  fac(3) = 3 * fac(2)，求fac(2)

4.  fac(2) = 2 * fac(1)，求fac(1)

5.  fac(1) = 1

6.  fac(2) = 2 * fac(1) = 2*1 = 2

7.  fac(3) = 3 * fac(2) = 3* 2 = 6

8.  fac(4) = 4 * fac(3) = 4*6 = 24

9.  fac(5) = 5 * fac(4) = 5*24 = 120

// 一个简单的阶乘函数  
var f = function (x) {  
    if (x === 1) {  
        return 1;  
    } else {  
        return x * f(x - 1);  
    }  
};