算法与数据结构学习笔记一（O(n^2)排序算法)

学习资料：https://github.com/liuyubobobo/Play-with-Algorithms
上面是C++和Java版本的代码
我跟着视频的思想写了一些JavaScript版本的
我的代码GitHub：
https://github.com/luxiaohai1024/studyCode/tree/master/algorithm-算法
（不断更新）

测试工具代码

(function (window) {
    let MyUtilMethod = {
        //生成有n个元素的随机数组，每个元素的随机范围为[rangeL,rangeR]
        "generateRandomArray": function (n, rangeL, rangeR) {
            let arr = [];
            for (let i = 0; i < n; i++) {
                arr[i] = Math.round(Math.random() * (rangeR - rangeL) + rangeL);
            }
            return arr;
        },
        //打印数组的函数
        "printArray": function (idName,arr) {
            let arrStr = '';
            let len = arr.length
            for (let i = 0; i < len; i++) {
                arrStr += (`
${arr[i]}
`);
            }
            $('#' + idName).append(arrStr);
        },
        //判断数组是否是已经排序的
        "isSorted" : function (arr) {
            let n = arr.length;
            for(let i=0; i < n-1; i++){
                if(arr[i] > arr[i+1]){
                    return false;
                }
            }
            return true;
        },
        //测试代码性能的函数
        "testSort" : function(methodName, methodFun, arr, showDivId){
            let start = new Date().getTime();
            methodFun(arr);
            let end = new Date().getTime();
            if(this.isSorted(arr)){
                $('#' + showDivId).append(`${methodName} -->${end - start}`);
            } else {
                $('#' + showDivId).append(`fail to Sort`);
            }
        },
        //拷贝数组
        "copeArray" : function (arr) {
            return arr.slice();
        }
     };
    window.MyUtilMethod = MyUtilMethod;
})(window);

排序算法

O(n^2)的排序算法

作用：

1. 基础。
2. 编码简单，易于实现，是一些简单情景的首选。
3. 在一些特殊情况下，简单的排序算法更有效。
4. 简单的排序算法思想衍生出复杂的排序算法。
5. 作为子过程，改进更复杂的排序算法。

选择排序 （Selection Sort）

1. 遍历数组，找到最小（大）的数，放在第一个位置。
2. 从第二个位置开始遍历数组，找到最小（大）的数，放在第二个位置。
3. 以此类推，直到排序完成。

代码实现

(function (window) { 
    function SelectionSort (arr) {
        let newArr = arr.concat();
        let n = arr.length;
        let middleValue = null;
        for (let i=0; i

插入排序 （Insertion Sort）

打牌的时候插入牌类似这种算法。

性能较差版本

以8、6、2、3、1、5、7、4为例

1. 第一个数不动（8、6、2、3、1、5、7、4）
2. 第二个数如果比第一个数小，和第一个数交换位置（6、8、2、3、1、5、7、4）
3. 第三个数如果比第二个数小，和第二个数交换位置（6、2、8、3、1、5、7、4）
4. 之前第三的数在第二的位置，将其与第一个数比较，如果比第一个数小，和第一个数交换位置（2、6、8、3、1、5、7、4）
5. 以此类推（2、3、6、8、1、5、7、4）

优点：可以提前结束循环，当当前的数没有并前一个数小的时候，直接跳出循环。

代码实现

(function (window) {
    function insertionSort(arr) {
        let newArr = arr.concat();
        let n = arr.length;
        let middleValue = null;
        for (let i = 1; i < n; i++) {
            //寻找元素arr[i]合适的插入位置
            for (let j = i; j > 0 && newArr[j] < newArr[j - 1]; j--) {
                middleValue = newArr[j];
                newArr[j] = newArr[j - 1];
                newArr[j - 1] = middleValue;
            }
        }
        return newArr;
    }
    window.insertionSort = insertionSort;
})(window)

改进版本

以8、6、2、3、1、5、7、4为例

1. 第二个数拷贝一份，不直接和第一位数比较。
   
2. 与第一位比较，如果比第一位小，第一位往后移到第二的位置。
   
3. 将拷贝的数放到第一的位置。
   
4. 第三个数复制
   
5. 考察第三个数是否应该放在第二的位置。
   
6. 第三的数如果比第一个数小，则第一个数放在第二的位置。第三的数放在第一的位置
   
   
7. 以此类推

代码实现

(function (window) {
    function insertionSort(arr) {
        let newArr = arr.concat();
        let n = arr.length;
        for (let i = 1; i < n; i++) {
            //寻找元素arr[i]合适的插入位置
            let copeValue = newArr[i];
            let j;      //j保存元素copeValue应该插入的位置
            for (j = i; j > 0 && newArr[j - 1] > copeValue; j--) {
                newArr[j] = newArr[j-1];
            }
            newArr[j] = copeValue;
        }
        return newArr;
    }
    window.insertionSort = insertionSort;
})(window)

冒泡排序 （Bubble Sort）

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

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码实现

(function (window) {
    function bubbleSort(arr) {
        let newArr = arr.concat();
        let i = arr.length,
            j;
        let tempExchangVal;
        while (i > 0) {
            for (j = 0; j < i - 1; j++) {
                if (newArr[j] > newArr[j + 1]) {
                    tempExchangVal = newArr[j];
                    newArr[j] = newArr[j + 1];
                    newArr[j + 1] = tempExchangVal;
                }
            }
            i--;
        }
        return newArr;
    }
    window.bubbleSort = bubbleSort;
})(window)

希尔排序 （Shell Sort）

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

1. 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
2. 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位

希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。

算法本身仅仅对原数组进行排序（通过增加索引的步长，例如是用i += step_size而不是i++）。

实例：
以[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，步长为5开始进行排序。


将上述四行数字，依序接在一起时我们得到：
[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ].
这时10已经移至正确位置了，然后再以3为步长进行排序：

最后以1步长进行排序（此时就是简单的插入排序了）。

代码实现

(function (window) {
    function ShellSort(arr) {
        let newArr = arr.concat();
        let n = arr.length;
        let gap, i, j;
        let temp;
        for (gap = n >> 1; gap > 0; gap >>= 1) {
            //有符号右移 a >> b;将 a 的二进制表示向右移 b (< 32) 位，丢弃被移出的位。
            for (i = gap; i < n; i++) {
                temp = newArr[i];
                for (j = i - gap; j >= 0 && newArr[j] > temp; j -= gap)
                    newArr[j + gap] = newArr[j];
                newArr[j + gap] = temp;
            }
        }
        return newArr;
    }
    window.ShellSort = ShellSort;
})(window);

插入排序所用时间

希尔排序所用时间