排序算法，冒泡排序，选择排序，插入排序，归并排序

function ArrayList() {
    let array = [];
    let swap = function (array1, array2) {
        if (array[array1] > array[array2]) {
            let temp = array[array1];
            array[array1] = array[array2];
            array[array2] = temp;
        }
    }
    this.insert = function (obj) {
        array.push(obj);
    }
    this.toString = function () {
        return array.join();
    }
    // 冒泡排序

 // 冒泡排序比较任何两个相邻的项，如果第一个比第二个大，则交换它们。元素项向上移动至
// 正确的顺序，就好像气泡升至表面一样，冒泡排序因此得名。
    this.bubbleSort = function () {
        for (let i = 0; i < array.length; i++) {
            for (let j = 0; j < array.length - 1; j++) {
            // for (let j = 0; j < array.length - 1 - i; j++) { // 改进后的冒泡排序
                // array[i] 是每一个i循环5次，依次向下；
                // array[j] 是循环完,全部数组，在第二次循环全部数组
                swap(j, j + 1);
            }
        }
        return array;
    }
    // 选择排序

 // 选择排序算法是一种原址比较排序算法。选择排序大致的思路是找到数据结构中的最小值并
// 将其放置在第一位，接着找到第二小的值并将其放在第二位，以此类推
    this.selectionSort = function () {
        let minNumber = null;
        for (let i = 0; i < array.length - 1; i++) {
            // minNumber = i;
            for (let j = i; j < array.length; j++) {
                if (array[i] > array[j]) {
                    minNumber = j;
                }
            }
            if (i !== minNumber) {
                swap(i, minNumber)
            }
        }
    }
    // 插入排序

 // 插入排序每次排一个数组项，以此方式构建最后的排序数组。假定第一项已经排序了，接着，
// 它和第二项进行比较，第二项是应该待在原位还是插到第一项之前呢？这样，头两项就已正确排
// 序，接着和第三项比较（它是该插入到第一、第二还是第三的位置呢？），以此类推。
    this.insertSort = function () {
        let [temp = null, j = null] = [];
        for (let i = 1; i < array.length; i++) { // 和第一个开始比
            j = i;
            temp = array[i];
            while (j > 0 && array[j - 1] > temp) {
                array[j] = array[j - 1];
                j--;
            }
            array[j] = temp;
        }
    }
    // 归并排序

 // 归并排序是第一个可以被实际使用的排序算法。你在本书中学到的前三个排序算法性能不
// 好，但归并排序性能不错，其复杂度为O(nlogn)。

// 归并排序是一种分治算法。其思想是将原始数组切分成较小的数组，直到每个小数组只有一
// 个位置，接着将小数组归并成较大的数组，直到最后只有一个排序完毕的大数组。
    let merge = function (left, right) {
        let [result = [], il = 0, ir = 0] = [];
        while (il < left.length && ir < right.length) {
            if (left[il] < right[ir]) {
                result.push(left[il++]);
            } else {
                result.push(right[ir++]);
            }
        }
        while (il < left.length) {
            result.push(left[il++]);
        }
        while (ir < right.length) {
            result.push(right[ir++]);
        }
        return result;
    }
    let mergeSortRec = function (array) {
        if (array.length === 1) {
            return array;
        }
        let mid = Math.floor(array.length / 2);
        let left = array.slice(0, mid);
        let right = array.slice(mid, array.length);
        return merge(mergeSortRec(left), mergeSortRec(right));
    }
    this.mergeSort = function () {
        array = mergeSortRec(array);
    }
}
let mySort = new ArrayList();
let arr2 = [4, 5, 1, 3, 2, 9, 'a', 'c', 'b'];
for (let i = 0; i < arr2.length; i++) {
    mySort.insert(arr2[i]);
}
function createNonSortedArray(size) {
    let arra = new ArrayList();
    for (let i = size; i > 0; i--) {
        arra.insert(i);
    }
    return arra;
}
let cArr = createNonSortedArray(5);
console.log(cArr.toString());
cArr.mergeSort();
console.log(cArr.toString());