十大经典排序算法--JS实现

 总结一下利用JS实现排序算法，具体算法如下图所示：

目录

1.冒泡排序

2.插入排序

3.选择排序

4.快速排序

---

---

十大排序算法时间复杂度：

相关概念：

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。

不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。

时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。

空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。

1.冒泡排序

算法描述：

            1.从小到大排序，比较相邻的两个元素，如果第二个元素大于第一个元素就互换

            2.对每个相邻的元素做同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该就是最大的数

            3.针对所有的元素重复以上步骤，除最后一个

            4.重复步骤1~3，直到排序完成

算法实现：

     function sortMaopao(arr) {
            let len = arr.length
            for (let i = 0; i < len - 1; i++) {
                for (let j = 0; j < len - 1 - i; j++) {
                    if (arr[j] > arr[j + 1]) { //相邻两个元素比较
                        let temp = arr[j +1] //元素互换
                        arr[j +1] = arr[j]
                        arr[j] = temp
                    }
                }
            }
            return arr
        }

2.插入排序

算法描述:

              1.从第一个元素开始，该元素默认是已排序的

                2.取出下一个元素，在已经排序的元素序列中从后向前扫描

                3.如果已排序好的元素大于新元素，则将已排序好的元素移到下一位置

                4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置

                5.将新元素插入到该位置后

                6.重复步骤2~5

算法实现

        function insertSort(arr) {
            let len = arr.length
            let preIndex, current
            for (let i = 1; i < len; i++) {
                preIndex = i - 1
                current = arr[i]
                while (preIndex >= 0 && arr[preIndex] > current) {
                    arr[preIndex + 1] = arr[preIndex]
                    preIndex--  //从后向前扫描
                }
                arr[preIndex + 1] = current
            }
            return arr
        }

3.选择排序

算法原理：

首先在未排序序列中找到最小/最大的值，放到排序序列的起始位置，然后，在剩余未排序元素中继续寻找最小/最大元素，放到已经排好序的序列的末尾，以此类推，直到所有元素都排序完毕。

算法实现：

      function selectSort(arr) {
            let minIndex, temp
            let len = arr.length
            for (let i = 0; i < len - 1; i++) {
                minIndex = i
                for (let j = i + 1; j < len; j++) {
                   if(arr[j] < arr[minIndex]) //寻找最小值
                   minIndex = j //保存最小值索引
                }
                temp = arr[i]
                arr[i] = arr[minIndex]
                arr[minIndex] = temp
            }
            return arr
        }

4.快速排序

快速快速是对冒泡排序的一种改进。其实现流程如下：

1.首先设定一个分界值，通过该值可以将数组分成左右两个部分。

2.将大于或者等于分界值的数据集中到分界值的右边，小于分界值的数据集中到分界值的左边。

3.然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。

4.重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

    function quickSort(array) {
        const sort = (arr, left = 0, right = arr.length - 1) => {
            if (left > right) {//如果左边的索引大于等于右边的索引说明整理完毕
                return
            }
            let i = left
            let j = right
            let base = arr[j] // 取无序数组最后一个数为基准值
            while (i < j) { //把所有比基准值小的数放在左边大的数放在右边
                while (i < j && arr[i] <= base) { //找到一个比基准值大的数交换
                    i++
                }
                arr[j] = arr[i] // 将较大的值放在右边如果没有比基准值大的数就是将自己赋值给自己（i 等于 j）
                while (i > j && arr[j] >= base) { //找到一个比基准值小的数交换
                    j--
                }
                arr[i] = arr[j] // 将较小的值放在左边如果没有找到比基准值小的数就是将自己赋值给自己（i 等于 j）
            }
            arr[j] = base // 将基准值放至中央位置完成一次循环（这时候 j 等于 i ）
            sort(arr, left, j - 1) // 将左边的无序数组重复上面的操作
            sort(arr, j + 1, right)  // 将右边的无序数组重复上面的操作
        }
        const newArr = array.concat() // 为了保证这个函数是纯函数拷贝一次数组
        sort(newArr)
        return newArr
    }

未完待续.....