排序算法

1. 冒泡排序：最慢、最容易实现。将一组数字进行升序排列，较大的值会浮动到数组的右侧，较小的值浮动到数组的左侧。

//第一次循环，开始比较当前元素与下一个元素的大小，如果比下一个元素小或者相等，则不需要交换两个元素的值；若比下一个元素大的话，则交换两个元素的值。然后，遍历整个数组，第一次遍历完之后，相同操作遍历第二遍。
const arr = [1, 20, 10, 30, 22, 11, 55, 24, 31, 88, 12, 100, 50];

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

function swap(arr, i, j) {
    let temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
bubbleSort(arr);
console.log(arr);

2. 选择排序：从数组的开头开始，将第一个元素和其他元素进行比较。检查完所有元素后，最小的元素会被放到数组的第一个位置，然后从第二个位置继续。

//选择排序，即每次都选择最小的，然后换位置
//第一遍，从数组中选出最小的，与第一个元素进行交换；第二遍，从第二个元素开始，找出最小的，与第二个元素进行交换；依次循环，完成排序
const arr = [1, 20, 10, 30, 22, 11, 55, 24, 31, 88, 12, 100, 50];

function swap(arr, i, j) {
    let temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

function selectSort(arr) {
    for (let i = 0; i < arr.length - 1; i++) {
        let index = i;
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[index] > arr[j]) {
                index = j;
            }
        }
        swap(arr, i, index);
    }
    return arr;
}

console.log(selectSort(arr));

3. 插入排序：

//插入排序，即将元素插入到已排序好的数组中
//首先，循环原数组，然后，将当前位置的元素，插入到之前已排序好的数组中，依次操作。
const arr = [101, 20, 10, 30, 22, 11, 55, 24, 31, 88, 12, 100, 50];

function insertSort(arr) {
    for (let i = 0; i < arr.length; i++) {
        let temp = arr[i];
        for (let j = 0; j < i; j++) {
            if (temp < arr[j] && j === 0) {
                arr.splice(i, 1);
                arr.unshift(temp); //可向数组的开头添加一个或更多元素并返回数组长度
                console.log(arr + 'a')
                break;
            } else if (temp > arr[j] && temp < arr[j + 1] && j < i - 1) {
                arr.splice(i, 1);
                arr.splice(j + 1, 0, temp);
                console.log(arr)
                break;
            }
        }
    }
    return arr;
}

insertSort(arr)

4. 希尔排序：通过定义一个间隔序列来表示在排序过程中进行比较的元素之间有多远的间隔。希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。

function shellSort(arr) {
    var len = arr.length,
        temp,
        gap = 1;
    while(gap < len/3) {          //动态定义间隔序列
        gap =gap*3+1;
    }
    for (gap; gap > 0; gap = Math.floor(gap/3)) {
        for (var i = gap; i < len; i++) {
            temp = arr[i];
            for (var j = i-gap; j >= 0 && arr[j] > temp; j-=gap) {
                arr[j+gap] = arr[j];
            }
            arr[j+gap] = temp;
        }
    }
    return arr;
}

5. 归并排序：把一系列排列好的子序列合并成一个打的完整的有序序列。

一开始每个元素都在左子序列或右子序列中。然后将左右子序列合并，首先每次合并成两个元素的子序列，然后合并成四个元素的子序列，3 和 5 除外，它们会一直保留到最后一次迭代，那时会把它们合并成右子序列，然后再与最后的左子序列合并成最终的有序数组。 

//归并排序，即将数组分成不同部分，然后注意排序之后，进行合并
//首先，将相邻的两个数进行排序，形成n/2对，然后在每两对进行合并，不断重复，直至排序完。
const arr = [1, 20, 10, 30, 22, 11, 55, 24, 31, 88, 12, 100, 50];

function mergeSort(arr) {
    const len = arr.length;

    for (let seg = 1; seg < len; seg += seg) {
        let arrB = [];
        for (let start = 0; start < len; start += 2 * seg) {
            let row = start;
            let mid = Math.min(start + seg, len);
            let heig = Math.min(start + 2 * seg, len);
            let start1 = start,
                end1 = mid;
            let start2 = mid,
                end2 = heig;
            while (start1 < end1 && start2 < end2) {
                arr[start1] < arr[start2] ? arrB.push(arr[start1++]) : arrB.push(arr[start2++]);
            }
            while (start1 < end1) {
                arrB.push(arr[start1++]);
            }
            while (start2 < end2) {
                arrB.push(arr[start2++]);
            }
        }
        arr = arrB;
    }
    return arr;
}

console.log(mergeSort(arr));

//归并排序，即将数组分成不同部分，然后注意排序之后，进行合并
//首先，将相邻的两个数进行排序，形成n/2对，然后在每两对进行合并，不断重复，直至排序完。
const arr = [1, 20, 10, 30, 22, 11, 55, 24, 31, 88, 12, 100, 50];

function mergeSort(arr, seg = 1) {
    const len = arr.length;
    if (seg > len) {
        return arr;
    }
    const arrB = [];
    for (var start = 0; start < len; start += 2 * seg) {
        let low = start,
            mid = Math.min(start + seg, len),
            heig = Math.min(start + 2 * seg, len);
        let start1 = low,
            end1 = mid;
        let start2 = mid,
            end2 = heig;
        while (start1 < end1 && start2 < end2) {
            arr[start1] < arr[start2] ? arrB.push(arr[start1++]) : arrB.push(arr[start2++]);
        }
        while (start1 < end1) {
            arrB.push(arr[start1++]);
        }
        while (start2 < end2) {
            arrB.push(arr[start2++]);
        }
    }
    return mergeSort(arrB, seg * 2);
}

console.log(mergeSort(arr));

6. 快速排序： 通过递归的方式将数据依次分解为包含较小元素和较大元素的不同子序列。该算法不断重复这个步骤直到所有数据都是有序的。

(1) 选择一个基准元素，将列表分隔成两个子序列;
(2) 对列表重新排序，将所有小于基准值的元素放在基准值的前面，所有大于基准值的元

素放在基准值的后面;
(3) 分别对较小元素的子序列和较大元素的子序列重复步骤 1 和 2。 

//快速排序，从它的名字就应该知道它很快，时间复杂度很低，性能很好。它将排序算法的时间复杂度降低到O(nlogn)
//首先，我们需要找到一个基数，然后将比基数小的值放在基数的左边，将比基数大的值放在基数的右边，之后进行递归那两组已经归类好的数组。
const arr = [1, 20, 10, 30, 22, 11, 55, 24, 31, 88, 12, 100, 50];

function quickSort(arr) {
    if (arr.length <= 1) {
        return arr;
    }
    let temp = arr[0];
    const left = [];
    const right = [];
    console.log("c" + temp)
    for (var i = 1; i < arr.length; i++) {
        if (arr[i] > temp) {
            right.push(arr[i]);
            console.log("a" + temp)
        } else {
            left.push(arr[i]);
            console.log("b" + temp)
        }
    }
    //concat用来连接两个或多个数组，该方法不会改变现有的数组，而仅仅会返回被连接数组的副本
    return quickSort(left).concat([temp], quickSort(right));
}

console.log(quickSort(arr))