• 【编程题目】查找最小的 k 个元素


    5.查找最小的 k 个元素(数组)
    题目:输入 n 个整数,输出其中最小的 k 个。
    例如输入 1,2,3,4,5,6,7 和 8 这 8 个数字,则最小的 4 个数字为 1,2,3 和 4。

    算法里面学过查找第k小的元素的O(n)算法

    试着实现了一下:

    注意new 初始化二维数组的方式 

    int (* a)[5] = new int[8][5];
    /*
    5.查找最小的 k 个元素(数组)
    题目:输入 n 个整数,输出其中最小的 k 个。
    例如输入 1,2,3,4,5,6,7 和 8 这 8 个数字,则最小的 4 个数字为 1,2,3 和 4。
    */
    
    #include <iostream>
    #include <algorithm>
    using namespace std;
    
    bool compare(int a, int b) //降序排列
    {
        return a > b;
    }
    
    //找到 一共有 n个 元素的 数组S 中 第k小 的数字  整个算法中,对除以5后余下的数字都做了特殊处理
    int Select(int * S, int k, int n)
    {
        if (n < 5) //对少于5个的做特殊处理
        {
            sort(S, S + n);
            return S[k - 1];
        }
        int subn = n/5 + ((n % 5 == 0) ? 0 : 1);
        int subnn = n/5;
        int (* subS)[5] = new int[subn][5];
        for (int i = 0; i < subnn; i++)
        {
            for (int j = 0; j < 5; j++)
            {
                subS[i][j] = S[i * 5 + j]; 
            }
            sort(subS[i], subS[i] + 5, compare); //5个一组,每组从大到小排序
        }
        for (int j = 0; j < n % 5; j++)
        {
            subS[subn - 1][j] = S[subn * 5 + j - 5];
        }
        sort(subS[subn - 1], subS[subn - 1] + n % 5, compare); 
    
        int * M = new int [subn];
        for (int i = 0; i < subn; i++)
        {
            M[i] = subS[i][2]; //M 中存储每组数字的中位数
        }
    
        int Mn = subnn;
        int m = Select(M, Mn/2 + (Mn % 2 == 0) ? 0 : 1, Mn);
        delete [] M;
    
        int * S1 = new int [n]; //存放小于等于m的数字
        int * S2 = new int [n];
        int S1n = 0; //记录有多少小于等于m的数字
        int S2n = 0;
    
        //找到相应的S1 与 S2中的元素
        for (int i = 0; i < subnn; i++)
        {
            if (subS[i][2] <= m)
            {
                for (int j = 0; j < 5; j++)
                {
                    if (j < 2)
                    {
                        if (subS[i][j] <= m)
                        {
                            S1[S1n++] = subS[i][j];
                        }
                        else
                        {
                            S2[S2n++] = subS[i][j];
                        }
                    }
                    else
                    {
                        S1[S1n++] = subS[i][j];
                    }
                }
            }
            else
            {
                for (int j = 0; j < 5; j++)
                {
                    if (j > 2)
                    {
                        if (subS[i][j] <= m)
                        {
                            S1[S1n++] = subS[i][j];
                        }
                        else
                        {
                            S2[S2n++] = subS[i][j];
                        }
                    }
                    else
                    {
                        S2[S2n++] = subS[i][j];
                    }
                }
            }
        }
        if (subnn != subn) //多余的数字特别处理
        {
            for (int j = 0; j < n % 5; j++)
            {
                if (subS[subn - 1][j] > m)
                {
                    S2[S2n++] = subS[subn - 1][j];
                }
                else
                {
                    S1[S1n++] = subS[subn - 1][j];
                }
            }
        }
    
        if (k == S1n)
        {
            delete [] S1;
            delete [] S2;
            return m;
        }
        else if (k < S1n)
        {
            return Select(S1, k, S1n);
        }
        else
        {
            return Select(S2, k - S1n, S2n);
        }
    
        delete [] S1;
        delete [] S2;
    }
    
    int main()
    {
        int a[8] = {1,2,3,4,5,6,7,8};
        int m = Select(a, 7, 8);
    
        return 0;
    }

    不过,我的代码看起来好长,好难受啊...

    网上有用堆做的,对堆不是很了解,要补一下知识。

    看了用堆的方法的原理,理论上会比我现在实现的这个算法慢一点

    方法是用堆维护k个最小元素

    下面来自:https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/02.01.md

    解法二

    咱们再进一步想想,题目没有要求最小的k个数有序,也没要求最后n-k个数有序。既然如此,就没有必要对所有元素进行排序。这时,咱们想到了用选择或交换排序,即:

    1、遍历n个数,把最先遍历到的k个数存入到大小为k的数组中,假设它们即是最小的k个数;
    2、对这k个数,利用选择或交换排序找到这k个元素中的最大值kmax(找最大值需要遍历这k个数,时间复杂度为O(k));
    3、继续遍历剩余n-k个数。假设每一次遍历到的新的元素的值为x,把x与kmax比较:如果x < kmax ,用x替换kmax,并回到第二步重新找出k个元素的数组中最大元素kmax‘;如果x >= kmax,则继续遍历不更新数组。

    每次遍历,更新或不更新数组的所用的时间为O(k)O(0)。故整趟下来,时间复杂度为n*O(k)=O(n*k)

    解法三

    更好的办法是维护容量为k的最大堆,原理跟解法二的方法相似:

    • 1、用容量为k的最大堆存储最先遍历到的k个数,同样假设它们即是最小的k个数;
    • 2、堆中元素是有序的,令k1<k2<...<kmax(kmax设为最大堆中的最大元素)
    • 3、遍历剩余n-k个数。假设每一次遍历到的新的元素的值为x,把x与堆顶元素kmax比较:如果x < kmax,用x替换kmax,然后更新堆(用时logk);否则不更新堆。

    这样下来,总的时间复杂度:O(k+(n-k)*logk)=O(n*logk)。此方法得益于堆中进行查找和更新的时间复杂度均为:O(logk)(若使用解法二:在数组中找出最大元素,时间复杂度:O(k))

    堆的实现代码:来自http://www.cnblogs.com/panweishadow/p/3632639.html

    public static void FindKMin(int[] sort, int k)
    {
        int[] heap = sort;
        int rootIndex = k / 2 - 1;
        while (rootIndex >= 0)
        {
            reheap(heap, rootIndex, k - 1);
            rootIndex--;
        }
     
        for (int i = k, len=heap.Length; i < len; i++)
        {
            if (heap[i]<heap[0])
            {
                heap[0] = heap[i];
                reheap(heap, 0, k - 1);
            }
        }
     
        Console.WriteLine("The {0} min element =",k);
        for (int i = 0; i < k; i++)
        {
            Console.Write(heap[i] + " ");
        }
    }
     
    private static void reheap(int[] heap, int rootIndex, int lastInddex)
    {
        int orphan = heap[rootIndex];
        bool done = false;
        int leftIndex = rootIndex * 2 + 1;
        while (!done && leftIndex <= lastInddex)
        {
            int largerIndex = leftIndex;
            if (leftIndex+1 <= lastInddex)
            {
                int rightIndex = leftIndex + 1;
                if (heap[rightIndex] > heap[leftIndex])
                {
                    largerIndex = rightIndex;
                }
            }
     
            if (orphan < heap[largerIndex])
            {
                heap[rootIndex] = heap[largerIndex];
                rootIndex = largerIndex;
                leftIndex = rootIndex * 2 + 1;
            }
            else
            {
                done = true;
            }
        }
     
        heap[rootIndex] = orphan;
    }
  • 相关阅读:
    Redis学习——(1)Redis安装与配置
    Ubuntu14.04安装Apache2+SVN+Trac
    Ubuntu14.04配置文件Apache2.conf
    Ubuntu系统用户忘记密码
    java中无符号类型的处理[转]
    Golang 切片(slice)扩容机制源码剖析
    无线网络:无线城域网和无线广域网
    vue项目 镜像重置的命令
    批量下载阿里云rpm包
    HttpClient psot和get请求
  • 原文地址:https://www.cnblogs.com/dplearning/p/3964779.html
Copyright © 2020-2023  润新知