详解冒泡排序，快速排序 ，斐波那契数列 (js实现)

==直接复制粘贴即可运行==。

# 冒泡排序  

       /*
       
        冒泡排序 : 将数组从小到大排序            
        每次比较下标相邻的两个数，如果前面的数大于后面的数，则这两个数交换位置。                         这样一来，第一次从0到1 ... 1到2,最后一个下标对应的数肯定是数组的最大值             但前面下标对应的值不一定是有序的。我们可以前面的数在进行排序。直到不被确定
        有序的数只剩一个时，我们就可以确定这个数组是有序的。 
        比如数组大小为10
        第一次轮询 比较9次  (这次剩下9个值不确定)
        第二次轮询 比较8次  (这次剩下8个值不确定)
        第三次轮询 比较7次  (这次剩下7个值不确定)
         ...
        第九次轮询 比较1次  (这次剩下1个值不确定)  可以停止了。  
        空间复杂度 O(1) 时间复杂度O(n^2)                     
    */
    
    let arr = [5, 9, 2, 10, 4, 7, 8, 1, 3, 6];
    function bubbleSort(arr) {
        console.log(arr);
        for (let i = 1; i < arr.length; i++) {
            for (let j = 0; j < arr.length - i; j++) {
                if (arr[j + 1] < arr[j]) {
                    let k = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = k;
                }
            }
        }
        console.log(arr);
    }
    // bubbleSort(arr);     

  ## 快速排序

        /*
        快速排序 
        1.现在一个数组里面找出一个数作为基准数。比如说index=arr[0],
        2.设数组的起始位置和终止位置为m,n ,首先在m处挖了个坑 先从后面往前面找，找到比index
        小的数为止，此时把这个数挖出来，填到之前的坑中。arr[m]=arr[n] ,再从前面向后找，
        找到比index大的数为止 ,把这个数挖出来，填到n对应的坑中。arr[n]=arr[m];依次交替，
        直到m>=n停止，此时把index填到m(n)对应的坑中。arr[m](arr[n])=index.
        此时arr[m]左边的数都小于它，右边的数都大于它。
        3.重复2,直到基准数的两边的数都是1个为止
        时间复杂度O(nlogn) 空间复杂度O(1)
        */
   
    function partitionSort(arr, left, right) {
        let m = left,
            n = right,
            index = arr[left];
        while (m < n) {
            while ((arr[n] >= index) && m < n) {
                n--;
            }
            arr[m] = arr[n];
            while ((arr[m] <= index) && m < n) {
                m++;
            }
            arr[n] = arr[m];
        }
        arr[m] = index;
        return m;
    }
    function quickSort(arr, left, right) {   //更加清晰
        if (left < right) {
            let p = partitionSort(arr, left, right);   // 递归
            quickSort(arr, left, p - 1);    //  左递归
            quickSort(arr, p + 1, right);   //右递归
        }
    }
    quickSort(arr, 0, arr.length - 1);
    console.log(arr);```

  ### 斐波那契数列及其优化

    /*斐波那契数列 第0项，第1项，第2项...第n项  找规律。
     0 1 1 2 3 5 ...  */
 
     
    function fib(n) {
        if (n == 0) {
            return 0;
        } else if (n == 1) {
            return 1;
        } else {
            return fib(n - 1) + fib(n - 2);   //正常的递归操作  逻辑清晰
        }
    }//递归有性能问题。
    function fib_(n) { //状态变量有点多，不太安全。 
        let last = 1;
        let last2 = 0;
        let current = last2;
        for (let i = 1; i <= n; i++) {
            last2 = last;
            last = current;
            current = last2 + last;
        }
        return current;
    }
    let n = fib_(5);
    console.log(n);

    function fib__(n) {   //优化   避免了重复运算。
        function fib___(n, a, b) {
            if (n == 0) return a
            else return fib_(n - 1, b, a + b)
        }
        return fib___(n, 0, 1)
    }