前端基础排序算法

冒泡排序

思想:每一次循环，两两比较，会将最大的一个数据选出来，n-1次循环就可以将数据一次进行排序完成

function bubble(arr){
    for(var i=0;i<arr.length-2;i++){
        for(var j=0;j<arr.length-1-i;j++){
            if(arr[j]>arr[j+1]){
                var temp=arr[j+1];
                arr[j+1]=arr[j];
                arr[j]=temp;
            }
        }
    }
}

冒泡排序优化

主要从两个方面进行优化：

1，已经全部有序 2，尾部有一部分有序

let arr=[1,3,55,6,3,4,1,2,5];
function optimizeBubble(arr){
    var temp;
    var sortIndex;
    var end=arr.length;
    for(var i=0;i<arr.length-1;i++){
        var sort=true;
        for(var j=0;j<end;j++){
            if(arr[j]>arr[j+1]){
                temp=arr[j+1];
                arr[j+1]=arr[j];
                arr[j]=temp;
                sort=false;
                sortIndex=j+1;
            }
        }
        end=sortIndex;
        if(sort)break;
    }
}
optimizeBubble(arr);
console.log(arr.toString());

快速排序

思想：每一次排序，选一个中间数作为比较的数，然后将大于这个数的项存放到一个数组里面，小于这个数据的再放到一个数组里面，这两个数组继续递归调用函数，直到数组中的数据小于等于1的时候，返回这个数组，最后将两个数组与中间数concat进行返回。

function  quick(arr){
    if(arr.length<=1){
        return arr;
    }
    var middleIndex=Math.floor(arr.length/2);
    var midderValue=arr.splice(middleIndex,1)[0];
    var leftArrray=[];
    var rightArray=[];


    for(var i=0;i<arr.length;i++){
        if(arr[i]<=midderValue){
            leftArrray.push(arr[i])
        }else{
            rightArray.push(arr[i])
        }
    }
    return quick(leftArrray).concat(midderValue,quick(rightArray));
}

插入排序

思想：将原数组的第一个数据放入新数组中，依次循环拿出原数组的一个数据，然后插入到已经排好序的新数组中，直到原数组中所有的数据都插入到新数组中，返回排好序的新数组，排序完成。

function insert(arr){
    var readyArr=[];
    readyArr.push(arr[0]);
    for(var i=1;i<arr.length-1;i++){
        var currentItem=arr[i];
        for(var j=readyArr.length-1;j>=0;j--){
            if(currentItem>readyArr[j]){
                readyArr.splice(j+1,0,currentItem);
                break;
            }
            if(j===0){
                readyArr.unshift(currentItem);
            }
        }
    }
    return readyArr;
}

选择排序

有很多人分不清选择排序和冒泡排序，冒泡排序的每一次比较有可能需要交换，所以每一次循环可能会交换多次。

而选择排序的每一次循环，只需要找出最小的数据的索引，最后进行交换就可以了，

冒泡排序每次会找出一个最大的数放在后面相应位置，选择排序每次会找出一个最小的数据放在相应位置

选择排序思想：每一次循环找出最小数据的索引，一次循环之后，与最小的数据进行交换。

function select(arr){
    for(var i=0;i<arr.length-1;i++){
        var min=i;
        for(j=i+1;j<arr.length;j++){
            if(arr[min]>arr[j]){
                min=j;
            }
        }
        if(min!==i){
            var temp=arr[i];
            arr[i]=arr[min];
            arr[min]=temp;
        }
    }
}