查找数组中第k大的数字

文章介绍了两种算法方法来寻找数组中的第K大元素:堆排序和快速排序。堆排序通过构建大顶堆并逐步移除最大值来找到第K大元素;快速排序则利用分治策略,在排序过程中找到第K大元素。这两种方法分别在堆调整和递归查找中实现了高效查找。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

 可以通过堆排序和快速排序来查找

堆排序应该是最直观最快速的。大顶堆建立之后,每次从堆中拿最顶端的最大值,第K个就是第K次拿最大值。

快速降序排序查找,每走一趟排序之后通过基准值和k比较,如果k大于基准值的index则到左边找,k小于基准值的index则在右边找,等于的话那就是基准值本身。每次只查找一边,不用像快速排序一样两边都要排序,查找效率比排序效率高一倍。

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <inttypes.h>
#include <string>
#include <string.h>
#include <sstream>
#include <memory>
#include <map>
#include <unordered_map>
#include <list>
#include <vector>
#include <set>
#include <deque>
#include <sys/time.h>
#include <unistd.h>
#include <sys/timeb.h>
#include <thread>
#include <iostream>

//g++ -std=c++11 -o exe_main main.cpp
//g++ -Wl,-as-needed -std=c++11 -o exe_main main.cpp -lpthread


//堆排序查找数组中第k大的数字
int heap_find_k_max(int data[], int n, int k)
{
        int k_max = 0;
        create_heap(data, n);

        int reverse_i = n - 1;

        for(int i = 0; i < k; ++i)
        {
                k_max = data[0];
                reverse_i = n - i - 1;
                swap(data[reverse_i], data[0]);
                heap_adjust(data, reverse_i, 0);
        }
        return k_max;
}

void heap_find_max(int data[], int n)
{
        printf("please input k:\n");
        int k = 0;
        scanf("%d", &k);
        int k_max = heap_find_k_max(data, sizeof(data)/sizeof(data[0]), k);
        printf("k_max:%d\n", k_max);
}

//快速排序查找数组中第k大的数字
int quick_find_k_max(int data[], int n, int begin, int end, int k)
{
        if(begin >= end){
                printf("begin:%d >= end:%d, return data[end]:%d\n", begin, end, data[end]);
                return data[end];
        }
        int k_index = k - 1;
        int key = data[begin];
        int i = begin, j = end;
        printf("i:%d, j:%d, key:%d\n", i, j, key);

        while (i < j)
        {
                while (i < j && data[j] <= key)
                {
                        printf("--j:%d, i:%d, key:%d\n", j, i, key);
                        --j;
                }
                if(i < j){
                        data[i] = data[j];
                }

                while (i < j && data[i] >= key)
                {
                        printf("++i:%d, j:%d, key:%d\n", i, j, key);
                        ++i;
                }
                if (i < j)
                {
                        data[j] = data[i];
                }
        }
        data[i] = key;

        if (k_index > i)
        {
                return quick_find_k_max(data, n, i + 1, end, k);
        }
        else if (k_index < i)
        {
                return quick_find_k_max(data, n, begin, i - 1, k);
        }
        else
        {
                printf("return:%d, k_index:%d, i:%d, j:%d\n", data[i], k_index, i, j);
                return data[i];
        }
        printf("err k_index:%d, i:%d, j:%d\n", k_index, i, j);
        return 0;
}

void quick_find_max(int data[], int n)
{
        printf("please input k:\n");
        int k = 0;
        scanf("%d", &k);
        int k_max = quick_find_k_max(data, n, 0, n-1, k);
        printf("k_max:%d\n", k_max);
}

int main()
{
        int data[] = {12,34,67,8,12,9842,789,23,978,3,10000,234,56,78,243,423,34,243,43,6785,312,1};

        //heap_find_max(data, sizeof(data)/sizeof(data[0]));

        quick_find_max(data, sizeof(data)/sizeof(data[0]));

        print_data(data,  sizeof(data)/sizeof(data[0]));

        return 0;
}

### 找到数组中第K元素的算法 要找到数组中第K的元素,可以采用多种方法。以下是几种常见的解决方案及其具体实现。 #### 方法一:基于排序的方法 通过先对整个数组进行降序排列,再取出索引为 `k-1` 的元素即可得到结果。这种方法简单易懂,但时间复杂度较高,通常为 \(O(n \log n)\),其中 \(n\) 是数组长度。 ```javascript var findKthLargest = function(nums, k) { nums.sort((a, b) => b - a); return nums[k - 1]; }; ``` 此方法利用了 JavaScript 中内置的 `sort()` 函数完成排序操作[^4]。 --- #### 方法二:快速选择 (Quickselect) 快速选择是一种基于快速排序的选择算法,用于在未完全排序的情况下查找第 K 或第 K 小的元素。其平均时间复杂度为 \(O(n)\),最坏情况下可能达到 \(O(n^2)\)。 核心思想是对数组执行一次划分操作(类似于快速排序),使得小于某个基准值的所有元素位于左侧,于该基准值的所有元素位于右侧。如果当前基准的位置正好等于目标位置,则找到了所需的元素;否则继续递归处理左半部分或右半部分。 ```python def partition(arr, low, high): pivot = arr[high] i = low - 1 for j in range(low, high): if arr[j] >= pivot: # 寻找较的元素 i += 1 arr[i], arr[j] = arr[j], arr[i] arr[i + 1], arr[high] = arr[high], arr[i + 1] return i + 1 def quick_select(arr, low, high, k): if low <= high: pi = partition(arr, low, high) if pi == k - 1: return arr[pi] elif pi > k - 1: return quick_select(arr, low, pi - 1, k) else: return quick_select(arr, pi + 1, high, k) def find_kth_largest(nums, k): return quick_select(nums, 0, len(nums) - 1, k) ``` 上述 Python 实现展示了如何使用快速选择算法高效地解决问题[^1]。 --- #### 方法三:堆排序 (Heap Sort) 另一种有效的方式是借助最堆或者最小堆结构。对于本问题而言,构建一个小固定的小顶堆更为合适: 1. 构造一个小顶堆并维护前 K 个较数值; 2. 遍历剩余数据时,仅当发现更的数才替换掉堆顶元素; 3. 最终堆顶即为目标值。 ```java public class Solution { public int findKthLargest(int[] nums, int k) { PriorityQueue<Integer> minHeap = new PriorityQueue<>(k); for (int num : nums) { if (minHeap.size() < k || num > minHeap.peek()) { minHeap.offer(num); } if (minHeap.size() > k) { minHeap.poll(); } } return minHeap.peek(); } } ``` 这段 Java 代码片段实现了基于优先队列的小顶堆逻辑[^3]。 --- #### 方法四:计数排序 (Counting Sort) 由于题目限定了输入范围 [-1e4, 1e4],因此还可以考虑应用桶排序的思想——统计各数字出现频率后再累加计算得出最终答案。不过这种方案适用场景有限制条件严格的情况之下才能发挥优势。 ```c++ vector<int> count(2 * MAX_VAL + 1, 0); // 假设MAX_VAL=10000 for(auto& val : nums){ ++count[val+MAX_VAL]; } int remain=k; for(int i=count.size()-1;i>=0;--i){ remain -= count[i]; if(remain<=0)return i-MAX_VAL; } return -1; ``` 这里 C++ 版本示范了如何运用计数排序技巧来解答此类特定区间内的查询需求。 --- ### 结论 综上所述,在实际开发过程中可以根据具体情况选用不同策略解决“寻找数组中第 K 元素”的任务。推荐优先尝试 **快速选择** 或者 **堆排序** 这两种效率较高的方式。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

tangcpp

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值