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

定义ArrayList及其排序方法

function ArrayList() {
    // 内部数组，用于存放待排序数据
    let array = [];

    // 内部交换函数，用于交换数组内两个位置的元素
    let swap = function(index1, index2) {
        if (array[index1] > array[index2]) {
            let temp = array[index1];
            array[index1] = array[index2];
            array[index2] = temp;
        }
    }

    // 插入元素到内部数组
    this.insert = function(item) {
        array.push(item);
    }

    // 转换内部数组为字符串
    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++) {
                swap(j, j + 1);
            }
        }
        return array;
    }

    // 选择排序方法
    // 选择排序通过找到最小（或最大）的元素并将其放到数组的起始位置来工作。
    this.selectionSort = function() {
        let minIndex = null;
        for (let i = 0; i < array.length - 1; i++) {
            for (let j = i; j < array.length; j++) {
                if (array[i] > array[j]) {
                    minIndex = j;
                }
            }
            if (i !== minIndex) {
                swap(i, minIndex)
            }
        }
    }

    // 插入排序方法
    // 插入排序通过将一个待排序的元素插入到已排序的元素列表中的合适位置来生成已排序的数组或列表。
    this.insertSort = function() {
        let temp, j;
        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;
        }
    }

    // 归并排序方法的辅助函数
    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);
    }
}

使用ArrayList排序

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 arr = new ArrayList();
    for (let i = size; i > 0; i--) {
        arr.insert(i);
    }
    return arr;
}

let cArr = createNonSortedArray(5);
console.log(cArr.toString());
cArr.mergeSort();
console.log(cArr.toString());