选择排序的实现

    1. const arr = [4, 1, 6, 9, 3, 2, 8, 7];
    3. /**
    4.  * 比较两个数 
    5.  * @param {Number} first 第一个数
    6.  * @param {Number} second 第二个数
    7.  * @returns boolean
    8.  */
    9. function compare(first, second) {
    10.     if (first >= second) return true;
    11.     else return false;
    12. }
    13. /**
    14.  * 交换两个数的位置
    15.  * @param {Array} arr  数组
    16.  * @param {Number} first 第一个数的索引值
    17.  * @param {Number} second 第二个数的索引值
    18.  */
    19. function exchange(arr, first, second) {
    20.     let temp = arr[first];
    21.     arr[first] = arr[second];
    22.     arr[second] = temp;
    23. }
    25. /**
    26.  * 选择排序
    27.  * @param {Array} arr  数据
    28.  */
    29. function scort(arr) {
    30.     for (let i = 0; i < arr.length; i++) {
    31.         let maxIndex = 0;
    32.         for (let j = 0; j < arr.length - i; j++) {
    33.             if (compare(arr[maxIndex], arr[j])) {
    34.                 maxIndex = j
    35.             }
    36.         }
    37.         console.log(arr.length)
    38.         exchange(arr, maxIndex, arr.length - i - 1)
    39.     }
    40. }
    42. scort(arr)
    43. console.log(arr)

    从上面代码可以看出，与冒泡排序差不多，但是与冒泡排序是有很大的差别的

    选择排序的逻辑
    image.png

    1. function scort(arr) {
    2.     for (let i = 0; i < arr.length; i++) {
    3.         let maxIndex = 0;
    4.         for (let j = 0; j < arr.length - i; j++) {
    5.             if (compare(arr[maxIndex], arr[j])) {
    6.                 maxIndex = j // 此时与冒泡排序的区别，冒泡排序是直接交换，但是选择排序是将该索引值保存下来，
    7.             }
    8.         }
    9.         console.log(arr.length)
    10.         exchange(arr, maxIndex, arr.length - i - 1) // 到第二层循环结束后才会进行交换
    11.     }
    12. }

    而冒泡排序的逻辑是
    image.png

    1. /**
    2.  * 冒泡排序
    3.  * @param {Array} arr 需要排序的数组
    4.  */
    5. function sort(arr) {
    6.     for (let j = 0; j < arr.length; j++) {
    7.         //  当前排序方式一大小排序，第一次循环中最大值会被换到最后，第一次就找到最大值，第二循环会找到第二大的值，依次往后
    8.         for (let i = 0; i < arr.length - 1 - j ; i++) {
    9.             if (compare(arr[i], arr[i + 1])) {
    10.                 exchange(arr, i, i + 1) // 此时是直接进行交换，选择排序，会将值保存下来
    11.             }
    12.         }
    13.     }
    14. }