无序数组中找第K大的数_落花逐流水的博客_无序数组找k大

类快排算法

leetcode215

由于只要求找出第k大的数，没必要将数组中所有值都排序。

典型解法：快速排序分组。

在数组中找到第k大的元素 取基准元素，将元素分为两个集合，一个集合元素比基准小，另一个比基准大 ，三种情况。 1.比基准大的元素数目标志位m正好为k-1，基准就是目的元素。 2.比基准大的元素标志位m小于k, 那么就在比基准小的集合里面找第(k-m)大的元素 3.若是比基准大的元素为m大于k，那就继续在该集合里面找第k大的元素。

快排中的partition算法，返回key在数组中的位置的cnt（相对于left的偏移量），如果cnt正好等于k，那么问题则得到解决；如果cnt小于k，去左边找第k个；如果cnt>k，则去右边找第k-cnt个。直到key的位置等于k-1，则找对问题的解。

1. /*快排中的划分算法*/

2. int partition(int* input, int low, int high)

3. {

4. int tmp = input[low]; // 取一个基准元素

6. while (low < high) {

7. while (low < high && input[high] <= tmp) {

8. high--;

9. }

10. input[low] = input[high];

12. while (low < high && input[low] >= tmp) {

13. low++;

14. }

15. input[high] = input[low];

16. }

18. input[low] = tmp;

19. return low;

20. }

22. // 参数left需要小于right

23. int findK(int* array, int left, int right, int k) {

24. //printf("%d %d %d\n", left, right, k);

25. int i = partition(array, left, right);

26. int cnt = i - left + 1;

27. if (k == cnt) {

28. return array[i];

29. } else if (k < cnt) {

30. return findK(array, left, i - 1, k);

31. } else if (k > cnt) {

32. return findK(array, i + 1, right, k-cnt);

33. }

34. return 0;

35. }

此解法的时间复杂度为O(N*lgK)，logK次每次O(N)，优于排序解法.

测试程序：

1. #include <iostream>

2. #include <vector>

3. using namespace std;

5. /*快排中的划分算法*/

6. int partition(int* input, int low, int high)

7. {

8. int tmp = input[low]; // 取一个基准元素

10. while (low < high) {

11. while (low < high && input[high] <= tmp) {

12. high--;

13. }

14. input[low] = input[high];

16. while (low < high && input[low] >= tmp) {

17. low++;

18. }

19. input[high] = input[low];

20. }

22. input[low] = tmp;

23. return low;

24. }

26. // 这里得到的是第k小，自己n-k转换下即可, 或者改下划分函数

27. int findK(int* array, int left, int right, int k) {

28. //printf("%d %d %d\n", left, right, k);

29. int i = partition(array, left, right);

30. int cnt = i - left + 1;

31. if (k == cnt) {

32. return array[i];

33. }

34. else if (k < cnt) {

35. return findK(array, left, i - 1, k);

36. }

37. else if (k > cnt) {

38. return findK(array, i + 1, right, k - cnt);

39. }

40. return 0;

41. }

44. int main()

45. {

46. vector<int> ilist = {9, 5, 8, 7, 3, 6, 2, 1, 4, 0};

47. int arr[10];

48. int n = ilist.size();

49. std::copy(ilist.begin(), ilist.end(), arr);

50. int k = 3;

51. int num = findK(arr, 0, n-1, k);

52. cout << num << endl;

53. system("pause");

54. return 0;

55. }

快排加二分查找：

1. int a[]={7,9,8,5,6,3,2,4,1,0};

2. const int K=6;

3. //解题思路就是利用快速排序，如果得到快速排序一次中间结果之后其所在位置即在

4. int QSort(int* a,int low,int high)

5. {

6. if(low<high)

7. {

8. int start=low,end=high;

9. int key=a[start];

10. while(start<end)

11. {

12. while(start<end&&a[end]<key)

13. {

14. end--;

15. }

16. a[start]=a[end];

17. while(start<end&&a[start]>key)

18. {

19. start++;

20. }

21. a[end]=a[start];

22. }

23. a[start]=key;

24. return start;

25. }

26. return -1;

27. }

28. int main()

29. {

30. int start=0,end=sizeof(a)/sizeof(int)-1;

31. int index=-2;

32. while(index+1!=K)

33. {

34. index=QSort(a,start,end);

35. if(index<K)

36. {

37. start=index+1;

38. }

39. else if(index>K)

40. {

41. end=index-1;

42. }

43. }

44. cout<<a[index]<<"即为所求\n";

45. }

最小堆解法

构造一个大小为k的最小堆，堆中根节点为最小值。如果数组中最大的几个数均在堆中，那么堆中根节点的值就是问题的解。

可以用STL中的优先队列实现，因为优先队列的内部就是最大堆/最小堆实现的。

此解法的时间复杂度O(NlogK)，N次logK。但是相比与类快速排序算法，需要额外的存储空间。

1. #include <iostream>

2. #include <vector>

3. using namespace std;

5. void maxHeapify(int* array, int size, int i) {

6. int left = 2 * i + 1;

7. int right = 2 * i + 2;

8. int small = i;

9. if (left < size) {

10. if (array[small] > array[left]) {

11. small = left;

12. }

13. }

14. if (right < size) {

15. if (array[small] > array[right]) {

16. small = right;

17. }

18. }

19. if (small != i) {

20. int temp = array[small];

21. array[small] = array[i];

22. array[i] = temp;

23. maxHeapify(array, size, small);

24. }

25. }

27. void buildHeap(int* array, int size) {

28. for (int i = size - 1; i >= 0; i--) {

29. maxHeapify(array, size, i);

30. }

31. }

33. int findKByHeap(int* array, int n, int k) {

34. buildHeap(array, k);

35. for (int i = k; i < n; i++) {

36. if (array[i] > array[0]) {

37. int temp = array[i];

38. array[i] = array[0];

39. array[0] = temp;

40. maxHeapify(array, k, 0);

41. }

42. }

43. return array[0];

44. }

47. int main()

48. {

49. vector<int> ilist = {9, 5, 8, 7, 3, 6, 2, 1, 4, 0};

50. int arr[10];

51. int n = ilist.size();

52. std::copy(ilist.begin(), ilist.end(), arr);

53. int k = 5;

54. int num = findKByHeap(arr, n, k);

55. cout << num << endl;

57. system("pause");

58. return 0;

59. }