js排序算法

1.冒泡排序：

function bubbleSort (arr) {
    let len = arr.length;
    //要进行多少轮排序
    for(let i = 0; i < len-1; i++) {
        //每一轮，相邻两位进行比较，大的放后面
        for(let j = 0; j < len-1-i ; j++) {
            if( arr[j] > arr[j+1] ){
                swap(arr,j,j+1);
            }
        }
    }
}
function swap(arr,i,j){
    let tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

let arr = [4,5,6,8,2,3,1,5];
bubbleSort(arr);

2.插入排序：

function insertSort (arr) {
    let len = arr.length;
    let j;
    let current;
    for(let i = 1; i < len; i++) {
        current = arr[i];
        j = i-1;
        while(j>=0 && arr[j] > current){
            arr[j+1] = arr[j];
            j --;
        }
        arr[j+1] = current;
    }
}

let arr = [4,5,6,8,2,3,1,5];
insertSort(arr);

3.选择排序：

function selectionSort(arr){
    let len = arr.length;
    let minIndex;
    for(let i = 0; i < len ; i++) {
        minIndex = i;
        for(let j = i+1; j < len ; j++) {
            if( arr[j] < arr[minIndex] ){
                minIndex = j;
            }
        }
        swap(arr,i,minIndex);
    }
}
function swap(arr,i,j){
    let tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

let arr = [4,5,6,8,2,3,1,5];
selectionSort(arr);

4.归并排序：

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

    if( len < 2 ){
        return arr;
    }

    let mid = Math.floor(len/2);
    let left = arr.slice(0,mid);
    let right = arr.slice(mid);//默认值到最后

    return merge(mergeSort(left),mergeSort(right));
}

//排序
function merge(left,right){
    let result = [];

    while ( left.length > 0 && right.length > 0 ){
        if( left[0] <= right[0] ){
            result.push( left.shift() );
        }else{
            result.push( right.shift() );
        }
    }

    while ( left.length ){
        result.push( left.shift() );
    }

    while ( right.length ){
        result.push( right.shift() );
    }

    return result;
}

let arr = [4,5,6,8,2,3,1,5];
mergeSort(arr);

5.快速排序：

function quickSort(arr){
    let len = arr.length;
    quick(arr,0,len-1);
}

function quick(arr,left,right){
    let point = left;
    let index = point+1;

    for(let i = index; i <= right; i++) {
        if( arr[i] < arr[point] ){
            swap(arr,i,index);
            index ++;
        }
    }

    swap(arr,point,index-1);

    index --;
    let leftE = index-1;
    let rightB = index+1;

    if( leftE > left ){
        quick(arr,point,leftE);
    }
    if( rightB < right){
        quick(arr,rightB,right);
    }

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

let arr = [8,6,9,10,18,5,4];
quickSort(arr);

6.堆排序：

function heapSort(arr){
    let len = arr.length;

    //初始堆调整
    for(let j = Math.floor(len/2)-1; j >=0 ; j--) {
        heap(arr,j,len);
    }

    for(let i = len-1; i > 0; i--) {
        swap(arr,0,i);
        len --;
        heap(arr,0,len);
    }
}

function heap(arr,i,len){
    let left = 2*i+1,
        right = 2*i+2,
        max = arr[i],
        maxIndex = i
    ;

    if( left < len && arr[left] > max ){
        max = arr[left];
        maxIndex = left;
    }

    if( right < len && arr[right] > max ){
        maxIndex = right;
    }

    if( maxIndex !== i ){
        swap(arr,i,maxIndex);
        heap(arr,maxIndex,len);
    }
}
function swap(arr,i,j){
    let tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

let arr = [10,12,8,9,5,18,4,3,2,7,15,13,12,16];
heapSort(arr);

7.计数排序：

//适用于：正整数和0，最大值不是特别大
function countSort (arr) {
    let count = [];
    arr.forEach(item=>{
        if(!count[item])count[item] = 0;
        count[item] ++;
    });

    let j=0;
    count.forEach((item,i)=>{
        while ( item > 0 ){
            arr[j] = i;
            item --;
            j ++;
        }
    });
}

let arr = [1,2,4,5,5,5,1,4,2,3,4,9,8,7,6,2,2];
countSort(arr);
    

8.桶排序：

function quickSort(arr){
    let len = arr.length;
    quick(arr,0,len-1);
}

function quick(arr,left,right){
    let point = left;
    let index = point+1;

    for(let i = index; i <= right; i++) {
        if( arr[i] < arr[point] ){
            swap(arr,i,index);
            index ++;
        }
    }

    swap(arr,point,index-1);

    index --;
    let leftE = index-1;
    let rightB = index+1;

    if( leftE > left ){
        quick(arr,point,leftE);
    }
    if( rightB < right){
        quick(arr,rightB,right);
    }

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

function bucketSort (arr) {
    let bucketSize = 10;
    let len = arr.length;
    let bucketArr = [];

    for(let i = 0; i < len; i++)
    {
        let index = Math.floor(arr[i]/bucketSize);
        if( !bucketArr[index] )bucketArr[index] = [];
        bucketArr[index].push(arr[i]);
    }

    let j = 0;
    for(let i = 0,len = bucketArr.length; i <len ; i++) {
        let item = bucketArr[i];
        if( !item )continue;
        quickSort(item);
        item.forEach(v=>{
            arr[j ++] = v;
        });
    }
}

let arr = [20,15,88,63,99,75,16,85,34];
bucketSort( arr );

9.基数排序：

function radixSort (arr) {
    let len = arr.length;
    //找出数组中最大数的位数
    let maxNum = arr[0];
    let radixArr = [];
    for(let i = 1; i < len; i++) {
        if( arr[i] > maxNum ){
            maxNum = arr[i];
        }
    }
    let maxDigit = maxNum.toString().length;

    let x = 10,y = 1;
    for(let i = 0; i < maxDigit; i++) {
        for(let j = 0; j < len; j++) {
            let v = Math.floor(arr[j] % x / y);
            if( !radixArr[v] )radixArr[v] = [];
            radixArr[v].push(arr[j]);
        }
        x *= 10;
        y *= 10;

        let index = 0;
        for(let j = 0,len = radixArr.length; j <len ; j++) {
            let item = radixArr[j];
            if(!item)continue;
            item.forEach(v=>{
                arr[index ++] = v;
            });
        }
        radixArr = [];
    }
}

let arr = [8898,456,123,12,7,9,56,23,456];
radixSort( arr );