JavaScript-排序算法知识讲解

冒泡排序

1. 逐层冒泡，第一次执行的冒泡，执行的比较次数为当前的长度 -1

2. 冒泡的总次数为长度 -1

3. 冒泡的比较次数一次比一次 少，最后到达一次结束

var arr = [1,3,8,5,7,6,2]
function bubbleSort(array){
    //冒泡的次数
    for(var i=1;i<array.length;i++){
        for(var j=0; j<array.length-i;j++){   //记录比较的次数
            if(array[j]>array[j+1]){   //先比较再进行换位置
                var temp = array[j]   //先保留j位置的值
                array[j] = array[j+1]   //将j+1位置的值赋给j位置
                array[j+1] = temp   //将保存的j位置的值赋给j+1位置
            }
        }
    }
}
bubbleSort(arr)

选择排序

1.每次选择当前的第一个数为最小值

2.这个值跟后面的所有值去比较，然后对应的比我这个值还小的，把下标记录起来，将这个下标赋值给min

3.判断min是否是我前面的给到的值，如果是不做操作，如果不是就交换位置

var arr = [1,3,8,5,7,6,2]
function selectorSort(array){
    for(var i =0;i<array.length-1;i++){  //只剩一个数就不比了
        var min = i
        for(var j=i+1;j<array.length;j++){
            if(array[min]>array[j]){  //如果比最小值还小
                min = j    //使用min记录一下这个值
            }
        }
        if(min!=i){  //min不指向我们开始指定的下标位置，则换位置
            var temp = array[i]
            array[i] = array[min]
            array[min] = temp
            
        }
    }
}
selectorSort(arr)

插入排序

1.从后往前比，初始下表为1

2.第一次比较为1和0比较，比较一次

3.第二次比较为2和1比较，1和0比较，比较两次

.....后面持续递增

第一种方法：
var arr = [1,3,8,5,7,6,2]
function insertSort(array){
    for(var i=1;i<array.length;i++){
        for(var j=i;j>0;j--){
            if(array[j-1]>array[j]){
                var temp = array[j-1]
                array[j-1] = array[j]
                array[j] = temp
            }
        }
    }
}
insertSort(arr)
​
第二种方法：
function insertion(array){
    for(var i=1;i<array.length;i++){
        var preIndex = i-1    //获取前一个下标
        var current = array[i];  //先保存当前的值，为防止丢失
        while(preIndex>0 && current<array[preIndex]){ //如果前一个下标大于等于0和当前的值为小于上一个
            arr[preIndex+1] = array[preIndex]   //将本身这个位置的值赋值为上一个
            preIndex--     //递减 ，继续往前走
        }
        array[preIndex+] = current     //当前的位置的值等于原本位置的值
    }
}
insertion(arr)
console.log(arr)

快速排序（冒泡排序升级）

1.快速排序，无限二分法，找中间轴
var arr = [1,3,8,5,7,6,2]
function quickSort(arr){
    if(arr.length<=1){   //长度为1或者小于1退出
        return arr    
    }
    var centerIndex = Math.round(arr.length/2)    //取中间值下标
    var center = arr.splice(center,1)[0]   //接收删除的中间值
    var left = []   //左边的数组
    var right = []   //右边的数组
    for(var i=0;i<arr.length;i++){   //循环遍历
        if(arr[i]<center){   //小于中间值，加到左边
            left.push(arr[i])
        }else{
            right.push(arr[i])    //大于中间值，加到右边
        }
    }
    return quickSort(left).concat([center,quickSort(right)])   //返回合并的数组
}
console.log(quickSort(arr));
​
​
2.第二种
function qSort(array){
    var max = array.length-1    //定义最大下标
    var min = 0  //最小下标
    var center = Math.round((max+min)/2)
    while(min<max && array[min]<array[center]){  //左边
        min++
        max = center
        center = Math.round(max+min)/2)
         }
    while(max>min && array[max]>array[center]){   //右边
        max--
        min = center
        center = Math.round((max+min)/2)
    }
    //判断换位置
    if(max==min){
        return array
    }
}