冒泡排序和遞歸

冒泡排序

什麼是冒泡排序: 數組當中相鄰的兩個數進行比較，數組當中比較小的數值向下沉，數值比較大的向上浮！外層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);  
    }  
};