剑指Offer40. 最小的K个数（js实现冒泡排序，快排，归并排序）

最新推荐文章于 2022-04-26 00:22:28 发布

SFONE_CC

最新推荐文章于 2022-04-26 00:22:28 发布

阅读量2.1k

点赞数 1

分类专栏：学习记录初级：lettcode代码自学文章标签： leetcode 算法排序算法

本文链接：https://blog.csdn.net/qq_38867012/article/details/123663930

版权

学习记录同时被 2 个专栏收录

11 篇文章 1 订阅

订阅专栏

初级：lettcode代码自学

6 篇文章 0 订阅

订阅专栏

题目：输入整数数组 arr，找出其中最小的 k个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。（力扣）
示例1：

输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]

示例2：

输入：arr = [0,1,2,1], k = 1
输出：[0]

限制：

0 <= k <= arr.length <= 10000
0 <= arr[i] <= 10000

话不多说，直接放代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>最小的k个数</title>
</head>
<body>
</body>
<script>

    //方法一：冒泡排序，在剑指offer中因为时间复杂度，过不了，但是结果应该没问题
    var getLeastNumbers1 = function(arr, k) {
        var temp
        for(i in arr){
           for(j in arr){
               if(arr[i] <= arr[j]){
                   temp = arr[i]
                   arr[i] = arr[j]
                   arr[j] = temp
               }
           }
        }
     
        return arr.slice(0,k)
    };

    getLeastNumbers1([5,8,3,6,3,7,0],3)


    //方法二：快速排序
    var getLeastNumbers2 = function(arr, k) {
        long = arr.length
        if (long <= 1){
            return arr
        }
        //排序算法
        var QuietSort = function (arr1,L,R) {
            if (L>=R){
                return ;
            }
            var left = L
            var right=R
            pivot = arr1[left]
            while (left<right){
                while (left<right && pivot <= arr1[right]){
                    right --
                }
                if(left < right){
                    arr1[left] = arr1[right]
                }
                while(left< right && pivot >= arr1[left]){
                    left ++
                }
                if(left < right){
                    arr1[right] = arr1[left]
                }
                if(left >= right){
                    arr1[left] = pivot
                }

            }
            QuietSort(arr1, L,right-1)   //递归排序左段
            QuietSort(arr1,right+1,R)    //递归排序右段
        }

        QuietSort(arr,0,long-1)

        console.log(arr.slice(0,k))
        return arr.slice(0,k)
    };

   getLeastNumbers2([3,2,1],2)

    //方法三：归并排序
    var getLeastNumbers3 = function(arr, k) {
        if(arr.length<=1){
            return arr
        }

        function mergeSort(arr1)  {
            let len = arr1.length
            if(len < 2){
                return arr1
            }
            let middle = Math.floor(len/2)       //返回小于等于x的最大整数

            let left = arr1.slice(0, middle)        //拆分成为两个序列
            let right = arr1.slice(middle, len)

            let mergeleft = mergeSort(left)          //递归拆分成length==2的多个子序列
            let mergeright = mergeSort(right)

            return merge(mergeleft,mergeright)       //合并排序后的两个序列
        }

        const merge = (left, right)=>{
            const result = [];

            while (left.length && right.length){    //当左右序列均不为0时
                if(left[0] <= right[0]) {        //左右两个序列的第一个元素判断，必须是<=，如果仅是小于，则排序会不稳定
                    result.push(left.shift())
                }
                else{
                    result.push(right.shift())
                }
            }

            //在进入下列循环时，必有一个序列已经全部添加进result中了，这样才能跳出上述的while循环
            while (left.length) result.push(left.shift());
            while (right.length) result.push(right.shift());
            return result          //返回新序列的结果
        }

        mergeSort(arr)
        console.log(mergeSort(arr).slice(0,k))
        return mergeSort(arr).slice(0,k)
    };

    getLeastNumbers3([3,2,1],2)

</script>
</html>