前端必会算法之排序

冒泡排序

背景：乱序数组排序

var arr = [4, 1, 6, 9, 3, 2, 7, 8];
function getMin(arr) {
    if (arr == null || arr.length == 0) return;
    var index = -1;
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] != null && arr[i] < arr[index] || arr[i] != null && index == -1) {
            index = i;
        }
    }
    var result = arr[index];
    arr[index] = null;
    return result;
}
function sort(arr) {
    var newArr = new Array(arr.length);
    for (var i = 0; i < newArr.length; i++) {
        newArr[i] = getMin(arr);
    }
    return newArr;
}
console.log(sort(arr));

冒泡排序:每一次循环都把最大的排在最后面

var arr = [4, 1, 6, 9, 3, 2, 7, 8];
// 排序不是比较大小，本质是比较和交换
function compare(a,b){//比较之后需要得出是否需要交换
    if(b < a) return true;
    else return false;
}
function exchange(arr, a, b){//将数组ab位置里面的值交换
    var temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}
function sort(arr){
    for(var i = 0; i < arr.length; i++){//要进行n次筛选
        for(var j = 0; j < arr.length - 1 - i; j++){//少i圈   里面的for是进行一次筛选选出最大的
            if(compare(arr[j],arr[j+1])){
                exchange(arr, j, j+1);
            }
        }
    }


}
sort(arr);
console.log(arr);

选择排序

var arr = [4, 1, 6, 9, 3, 2, 7, 8];

function compare(a,b){
    if(a < b) return true;
    else return false;
}
function exchange(arr, a, b){
    var temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}
function sort(arr){
    for(var i = 0; i< arr.length; i++){// 循环全部圈数
        var maxIndex = 0;//最大的数的序号
        for(var j = 0; j < arr.length - i; j++){//一圈下来谁是最大的
            if(compare(arr[maxIndex], arr[j])){
                maxIndex = j;//j是最大的
            }
        }
        exchange(arr, maxIndex,arr.length-1-i);
    }
}
sort(arr);
console.log(arr);
// 任何一种排序算法，都没有优劣之分，只有是否适合的场景 越乱，越适合选择排序；越有序，越适合冒泡排序

简单快速排序

算法导论

var arr = [4, 1, 6, 9, 3, 2, 8, 7];
function quickSort(arr) {
    if (arr == null || arr.length == 0) return [];//如果不是空数组，则没有对应的push方法，导致报错
    //选班长，小的站在左边，大的站在右边
    var leader = arr[0];
    var left = [];
    var right = [];
    for (var i = 1; i < arr.length; i++) {
        if (arr[i] < leader) left.push(arr[i]);
        else right.push(arr[i]);
    }
    left = quickSort(left);
    right = quickSort(right);
    left.push(leader);
    return left.concat(right);
}
console.log(quickSort(arr));

标准快速排序

默认左闭右开

var arr = [4, 1, 6, 9, 3, 2, 8, 7];

function swap(arr, a, b) {
    var temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}

function quickSort2(arr, begin, end) {
    if (begin >= end - 1) return;
    var left = begin;
    var right = end;
    do {
        do left++; while (left < right && arr[left] < arr[begin]);
        do right--; while (right > left && arr[right] > arr[begin]);
        if (left < right) swap(arr, left, right)
    } while (left < right);
    var swapPoint = left == right ? right - 1 : right;
    swap(arr, begin, swapPoint);
    quickSort2(arr, begin, swapPoint);
    quickSort2(arr, swapPoint + 1, end);
}

function quickSort(arr) {
    quickSort2(arr, 0, arr.length);
}

quickSort(arr);
console.log(arr);

欢迎来CodeAc领取海量前端资料