js数组的冒泡排序， 选择排序， 以及快速排序

// 对于数组的排序
var arr = [4, 1, 2, 5, 3, 7, 6, 9, 0, 8];
// 冒泡排序
// 冒泡排序的思想在于，数组中的两两相互对比，大小的顺序调换位置
// 排序的意思是先比较，后交换位置
/**
 * 比较两个数字的大小
 * @param a {Number} 第一个数字
 * @param b {Number} 第二个数字
 * @returns {boolean}
 */
function compare(a, b) {
    return a > b;
}
/**
 * 交换数组中的位置
 * @param arr 数组
 * @param a 第一个位置
 * @param b 第二个位置
 */
function exchange(arr, a, b) {
    var temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}
/**
 * 冒泡排序： 每一圈可以得出一个最大值或者最小值, 冒泡排序适合用于数据结构不怎么乱的，也就是说数组的顺序完整性比较好的
 * @param arr
 */
function popSort(arr) {
    if (arr.length === 0) return
    // 第一圈循环 总共需要比较的次数
    for (var i = 0; i < arr.length; i++) {
        // 第二圈循环得出最大值或者最小值， 减i的原因是因为上一圈已经得出了一个最大或者最小值
        for (var j = 0; j < arr.length - 1 - i; j++) {
            if (compare(arr[j], arr[j + 1])) {
                exchange(arr, j, j + 1);
            }
        }
    }
}
// popSort(arr);
// console.log(arr);
// 选择排序
function chooseSort(arr) {
    // 算法的完整性，代码绝对不允许报错
    if (arr.length === 0) return
    // 第一圈循环总共需要的排序次数
    for (var i = 0; i < arr.length; i++) {
        // 第二圈用于选择最大，放到右边
        var maxIndex = 0;
        for (var j = 0; j < arr.length - i; j++) {
            if (compare(arr[j], arr[maxIndex])) {
                maxIndex = j;
            }
        }
        exchange(arr, maxIndex, arr.length - 1 - i)
    }
}
// chooseSort(arr);
// console.log(arr);
/**
 * 快速排序 简化版 只是用于理解快速排序，不太建议用于大数据的实战，每一个递归创建数组，浪费空间
 * @param arr {Array} 需要排序的数组
 */
function simpleQuickSort(arr) {
    // 算法中，这一行容错机制不能没有，因为算法不可以报错
    if (arr == null || arr.length === 0) return []
    // 分成两个部分
    var left = [], right = [];
    // 选取参照物
    var leader = arr[0];
    // 注意这里是从1开始
    for (var i = 1; i < arr.length; i++) {
        if (arr [i] > leader) {
            right.push(arr[i]);
        } else {
            left.push(arr[i]);
        }
    }
    left = simpleQuickSort(left);
    right = simpleQuickSort(right);
    // 把0那个数给拼接上
    left.push(leader);
    // 返回排好序的数据
    return left.concat(right);
}
// console.log(simpleQuickSort(arr));
/**
 * 数组的快速排序
 * @param arr {Array} 需要排序的数组
 * @param begin {Number} 开始位置
 * @param end {Number} 结束位置
 */
function complexQuickSort(arr, begin, end) {
    // 如果左边的下标大于右边的下标 直接结束
    if (begin >= end - 1) return
    // 获取左侧的开始下标， 右侧开始下标， 以及参照物
    var left = begin, right = end;
    do {
        // 当左侧参照物的值小于的时候，直接移动右边
        do {
            left++
        } while (arr[left] < arr[begin] && left < right);
        do {
            right--
        } while (arr[right] > arr[begin] && left < right);
        // 如果左侧参照物的值大于参照物，并且右侧的小于参照物，则交换位置
        if (left < right) {
            exchange(arr, left, right);
        }
    } while (left < right);
    // 获取第二个参照物的下标
    var swapPoint = left === right ? right - 1 : right;
    exchange(arr, begin, swapPoint);
    complexQuickSort(arr, begin, swapPoint);
    complexQuickSort(arr, swapPoint + 1, end);
}
complexQuickSort(arr, 0, arr.length);
console.log(arr)