排序：冒泡排序、选择排序、快速排序

冒泡排序

冒泡排序原理

• 两相邻的数依次比较
• 若从小到大排列两两比较时前一个数比后一个数大互换位置
• 相互比较完一轮最大的数就会到最后面，并且不再参与比较
• 循环比较 直到比较完成

简单冒泡排序实现

let arr \= \[9,5,1,3,2,4,8,7,6\]  
​  
function bubbleSort(arr) {  
    // 1. 确定外层循环次数  
    for(let i \= 0; i < arr.length ; i++) {  
        // 2. 确定内层循环次数  
        for (let j \= 0; j < arr.length \- i; j++) {  
            // 3. 两两进行比较，如果后面的值大于前面的值，将值互换  
            if(arr\[j+1\] < arr\[j\]) {  
                 let flag \= arr\[j+1\]  
                 arr\[j+1\] \=  arr\[j\]  
                 arr\[j\] \= flag  
            }  
        }  
    }  
    // 4. 返回修改后的数组  
    return arr  
}  
​  
console.log('冒泡排序', bubbleSort(arr))

选择排序

选择排序原理

• 找未排序的元素中最小的数
• 将最小数与起始位置互换
• 直到排序完成

简单选择排序实现

function checkSort(arr) {  
    // 1. 定义一个数组用于接受最小值  
    let result \= \[\]  
    // 2. 定义一个最小索引作为中间值  
    let minIndex  
    // 3. 确定外层循环次数  
    for (let i \= 0; i < arr.length; i++) {  
        // 4. 设置初始最小值为i  
        minIndex \= i  
        // 5. 确定内层循环次数  
        for (let j \= i + 1; j < arr.length; j++) {  
            // 6. 如果arr\[j\]的数值小于arr\[minIndex\]，将minIndex赋值为j  
            if (arr\[minIndex\] \> arr\[j\]) {  
                minIndex \= j  
            }  
        }  
        // 7. 一次内层循环之后得到得就是最小值，将值push到ruselt数组中  
        result.push(arr\[minIndex\])  
     }  
     // 8. 返回排序好的数组  
     return result  
}  
​  
console.log('选择排序', checkSort(arr))

快速排序

快速排序原理

• 采用二分法取出中间数
• 将数组得每个值都与这个中间数作比较
• 小的放左边，大的放右边
• 知道数组为空
• 运用到了递归

简单快速排序实现

function quickSort(arr) {  
    // 1. 判断数组是否为空，为空则返回空数组，不做操作  
    // 如果没有则会报错Maximum call stack size exceeded即造成：超出最大调用堆栈大小。  
    // 原因是，递归函数没有停止的判断  
    if(arr.length \== 0) {  
        return \[\]  
    }   
    // 2. 取得中间值  
    let middleIndex \= Math.floor(arr.length / 2)  
    let middleValue \= arr.splice(middleIndex, 1)  
    // 3. 定义较小数组和较大数组  
    let lesser \= \[\]  
    let bigger \= \[\]  
 // 4. 遍历数组的值并与中间值作比较，分别将较大值和较小值放入较小数组和较大数组  
    for (let i \= 0; i < arr.length; i++) {  
        if(arr\[i\] < middleValue) {  
            lesser.push(arr\[i\])  
        }  
        else {  
            bigger.push(arr\[i\])  
        }  
    }  
 // 5. 返回一个一个通过递归函数调用拼接的数组  
    return quickSort(lesser).concat(middleValue,quickSort(bigger))  
}  
​  
console.log('快速排序', quickSort(arr))