js中常见的数组排序

js中常见的数组排序

最开始学习编程，遇到排序问题，一般都是用冒泡法，因为冒泡法好理解，代码量少。但是这种算法时间复杂度高，当需要排序的元素较多时，程序运行时间很长，因此产生了快速排序算法。该算法的实现可分为以下几步：

1. 在数组中选一个基准数（通常为数组中间的数）；
2. 将数组中小于基准数的数据移到基准数左边，大于基准数的移到右边；
3. 对于基准数左、右两边的数组，不断重复以上两个过程，直到每个子集只有一个元素，即为全部有序。

快速排序法

选择排序的关键点：
（1）采用双层循环：时间复杂度也是O（n的平方）
外层循环表示的是排序的趟数，n个数字需要n-1趟，因此，外层循环的次数是n-1次；同时也代表数的位置。
内层循环表示的是每一趟排序的数字。根据选择排序的思想，第i趟排序时，最前面的位置就是i，用一个循环来不断更新。
（2）找到最值数的位置，将该位置的数和当前序列最前面（最后面）位置的数进行交换；。（稳定排序）

export const quicksort = (arr: any, isAsc?: Boolean) => {
  //4.判断数组的长度，如果数组的长度小于1 停止执行；
  if (arr.length <= 1) {
    return arr;
  }
  //1.找到数组的中间值（向下取整或者向上取整都可以，这里向下取整），并将原数组中的中间值去掉
  let middleIndex = Math.floor(arr.length / 2);
  let middleValue = arr.splice(middleIndex, 1);
  //2.创建左右的新数组，大于中间数的放在右边，反之左边
  let arrLeft = [],
    arrRight = [];
  if (isAsc) {
    //升序
    for (let i = 0; i < arr.length; i++) {
      let temp = arr[i];
      temp <= middleValue ? arrLeft.push(temp) : arrRight.push(temp);
    }
  } else {
    //降序
    for (let i = 0; i < arr.length; i++) {
      let temp = arr[i];
      temp >= middleValue ? arrLeft.push(temp) : arrRight.push(temp);
    }
  }

  //3.利用函数的递归，并且concat拼接数组
  return quicksort(arrLeft,isAsc).concat(middleValue, quicksort(arrRight,isAsc));
};

<script>
    function quicksort(arr) {
        //4.判断数组的长度，如果数组的长度小于1 停止执行；
        if (arr.length <= 1) {
            return arr;
        }
        //1.找到数组的中间值（向下取整或者向上取整都可以，这里向下取整），并将原数组中的中间值去掉
        let middleIndex = Math.floor(arr.length / 2);
        let middleValue = arr.splice(middleIndex, 1);
        //2.创建左右的新数组，大于中间数的放在右边，反之左边
        let arrLeft = [],
            arrRight = [];
        for (let i = 0; i < arr.length; i++) {
            let temp = arr[i];
            temp < middleValue ? arrLeft.push(temp) : arrRight.push(temp);
        }
        //3.利用函数的递归，并且concat拼接数组
        return quicksort(arrLeft).concat(middleValue, quicksort(arrRight));
    }

    console.log(quicksort([5, 2, 6, 723, 234, 7, 9, 89, 456, 23, 4, 213, 42, 35, 3, 654, 67, 56, 7, 32, 4, 234, ]));
</script>

选择排序法

 function selsetSort(arr) {
        var len = arr.length;
        var index;
        for (var i = 0; i < len - 1; i++) {
            index = i;
            for (var j = i + 1; j < len; j++) {
                if (arr[index] > arr[j]) { //寻找最小值
                    index = j; //保存最小值的索引
                }
            }
            if (index != i) {
                var temp = arr[i];
                arr[i] = arr[index];
                arr[index] = temp;
            }
        }
        return arr;
    }

冒泡排序法

通过对待排序的序列从前向后依次比较相邻元素的值，如果发现逆序则交换。
逆序的含义：如果想把序列从小到大排序，那么两个数中前面的比后面的大就是逆序。

  function selsetSort(arr) {
        let num = 0;
        for (let i = 0; i < arr.length; i++) {
            for (let j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    num = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = num;
                }
            }
        }

        return arr;
    }
    console.log(selsetSort(arr));