基于快排的partition实现TOPK问题

 

类似于快速排序,首先选择一个划分元,如果这个划分元的序号index刚好等于k,那么这个划分元以及左边的数,刚好组成了top-k small data;如果index>k, 那top-k small data在index的左边,那么就继续递归从index-1和数中选取top-k.如果index < k,那么说明还要从index的右边,选取top-(k-index) small data.

  1. public class TopK_Quick {
  2. public static int Partition(int a[],int low,int high)
  3. {
  4. a[0]=a[low];
  5. int pivokey = a[low];
  6. while(low<high)
  7. {
  8. while(low<high && a[high]>=pivokey) --high;
  9. a[low] = a[high];
  10. while(low<high && a[low]<=pivokey) ++low;
  11. a[high]= a[low];
  12. }
  13. a[low]=a[0];
  14. return low;
  15. }
  16. public static void display(int a[],int k)
  17. {
  18. for(int i=1;i<=k;i++)
  19. {
  20. System.out.print(a[i]+" ");
  21. }
  22. }
  23. public static int selectK(int a[],int start,int end,int k)
  24. {
  25. int index = 0;
  26. if(start<end)
  27. {
  28. index = Partition(a,start,end);
  29. if(index == k)//正好找到第k大的数
  30. {
  31. index = k;
  32. }else if(index < k)//还要从index的右边找k-index个数
  33. {
  34. index = selectK(a,index+1,end,k-index);
  35. }else if(index > k)//k个数都在Index的左边
  36. {
  37. index = selectK(a,start,index-1,k);
  38. }
  39. }
  40. return index;
  41. }
  42. public static void main(String args[])
  43. {
  44. int k=0;
  45. int a[]={0,49,38,29,65,97,76,13,27,49,22,19};
  46. if(k>0&&k<=a.length-1)
  47. {
  48. selectK(a,1,a.length-1,k);
  49. display(a,k);
  50. }else{
  51. System.out.println("Are You Kidding Me?");
  52. }
  53. }
  54. }
基于快排思想的选择算法(QuickSelect),可以在未排序的数组中查找第k小的元素或第k大的元素。它的基本思想是利用快排的划分思想,每次选择一个基准元素,将数组划分为两个子数组,并判断目标元素所在的子数组在哪里,然后递归处理该子数组,直到找到目标元素。 下面是Java实现基于快排思想的选择算法的示例代码: ```java public static int quickSelect(int[] arr, int left, int right, int k) { if (left == right) { return arr[left]; } int pivotIndex = partition(arr, left, right); if (k == pivotIndex) { return arr[k]; } else if (k < pivotIndex) { return quickSelect(arr, left, pivotIndex - 1, k); } else { return quickSelect(arr, pivotIndex + 1, right, k); } } private static int partition(int[] arr, int left, int right) { int pivot = arr[left]; int i = left + 1; int j = right; while (true) { while (i <= j && arr[i] < pivot) { i++; } while (i <= j && arr[j] > pivot) { j--; } if (i >= j) { break; } swap(arr, i, j); i++; j--; } swap(arr, left, j); return j; } private static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } ``` 这段代码中,我们首先在数组arr的[left, right]范围内选择一个基准元素pivot,然后对子数组进行划分,将小于pivot的元素移到pivot左边,大于pivot的元素移到pivot右边,最后返回pivot所在的索引pivotIndex。 然后我们将目标元素的索引与pivotIndex进行比较,如果相等,直接返回目标元素。如果目标元素的索引小于pivotIndex,那么说明目标元素在左半部分,我们就在左半部分递归查找。如果目标元素的索引大于pivotIndex,那么说明目标元素在右半部分,我们就在右半部分递归查找。这样反复递归,直到找到目标元素。 最后,我们可以在主函数中调用quickSelect方法,将数组arr的范围[left, right]和目标元素的索引k传入。例如,我们可以查找数组arr中第k小的元素: ```java int k = 3; // 要查找第3小的元素 int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}; int n = arr.length; int result = quickSelect(arr, 0, n - 1, k - 1); System.out.println(result); ``` 输出结果为2,表示数组中第3小的元素为2。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值