Java实现线性时间选择算法

现在有一个问题，给你一个线性数组n，让你求第y小的数是多少？

正常人的思路都是先排序，然后直接输出，那我们用快排来写，他的时间复杂度O(NlogN)

最坏的话可能O(N^2)，所以当数据量上来的时候很明显这种算法是低级的

那我们应该怎么去解决这个问题呢

很明显我们会选择线性时间选择，它的原理是什么呢？

其实你只要懂快排就懂线性，快排是不是把每个数找到他们应该在的位置最后来实现排序，那么我们是不是可以把数组n等分成y份，然后找出每一份中的中位数，再将每一份数组的中位数进行排序找出中位数中的中位数 z，再进行快排一样的流程，找出z在数组中应该在什么位置，然后z前面有多少个元素，z后面有多少个元素，如果z前面的元素小于等于k往前递归，大于前面的元素往后递归，递归的出口我们后面再讲，反正你这样一搞时间复杂度就是O（n）

那么我们现在来一个个解决问题，首先将数组分为y份，这么个分法呢，这里我们可以按五个元素一分，纯个人喜好，你愿意用多少就用多少

为了找出分好数组中的中位数，我们明显要用排序来写，我这里选择的是选择排序，你喜欢用什么就用什么，跟时间复杂度没关系，因为元素都是确定的里面就五个，时间复杂度都是o(1)

 public static void Slsort(int[] a,int p,int r){
        for(int i = p + 1;i <= r;i++){
            int index = i;
            for(int j = i + 1;j <= r;j++){
                if(a[j] < a[index]){
                    index  = j;
                }
            }
            Swap(a,i,index);
        }
    }

下一个问题找中位数

tips：这里我们找中位数，只是要这五个里面元素中按照元素值排序的中位数下标，所以不需要在原数组内改变他们的位置，只要找的中位数数字的下标，返回就ok了

 public static int SearchMid(int[] a,int l,int r){
        int[] b = new int[r - l + 1];
        for(int i = l;i <= r;i++){ //数组a是从l~r，b不是
            b[i - l] = a[i];
        }
        Slsort(b,0,r - l);
        for (int i = l; i <= r; ++i)
        {
            if (a[i] == b[(r - l + 1) / 2])
            {
                return i; //返回的是a里面的中位数下标
            }
        }
        return 0;
    }

下一个问题找中位数在数组中应该在的位置，代码跟快排的基本一致，看不懂可以看我的上一篇快排

 public static int Partition(int[] array,int l,int r,int x){
        Swap(array,r,x);
        int j = l;
        int i = l;
        int pivot = r;
        while(j < pivot){
            if(array[j] < array[pivot]){
                Swap(array,i,j);
                i++;
                j++;
            }
            if(array[j] > array[pivot]){
                j++;
            }
        }
        Swap(array,i,pivot);
        return i;
    }

最终要解决的问题找k是哪个元素

这个递归函数一定要有递归出口，那我们怎么找递归出口呢，很明显，我每次递归都会把所有元素分组，分完组之后，我们要找筛选出中位数，然后进行下次递归，如果我们下次递归的的元素连五个都没有，那么我们就可以直接输出结果了，假如让你找第三小的元素你很好理解，那么找第11小的呢,所以你看到我写了当k >len,下一次要找的就是k - len，为什么呢明显你要的数前面十个都没有，那么他只可能是后面十个数的第一小的元素咯，那么我是不是只要从第11个元素开始找倒数第一小的元素就能找到第11小的元素了所以递归的出口就是 r - l + 1<= 5.

tips：如果元素总数不是5的倍数怎么办呢？这里我选择了一个math函数，我是以5为基准划分加入最后一组只剩下四个或三个等等小于五个的情况，我就会以剩下的所有元素为一组来找出他们的中位数

 public static int select(int[] a, int l, int r, int k) {
       if (r - l + 1 <= 5) {
           Slsort(a, l, r);
           return a[l + k - 1]; // 返回第k小的元素
       }
       // 将数组分成若干组，每组5个元素
       for (int i = 0; i < (r - l + 1) / 5; i++) {
           int left = l + 5 * i; // 当前组的左边界
           int right = Math.min(l + 5 * i + 4, r); // 当前组的右边界
           int mid = SearchMid(a, left, right); // 找到当前组的中位数
           Swap(a, mid, l + i);
       }
       // 对中位数组成的新数组进行递归调用select
       int pivot = select(a, l, l + (r - l + 1) / 5 - 1, (r - l + 6) / 10);
       // 根据pivot进行分区
       int i = Partition(a, l, r, pivot);
       int len = i - l + 1;
       if (k <= len) {
           return select(a, l, i, k);
       } else {
           return select(a, i + 1, r, k - len);
       }
   }

总代码

import java.util.Random;
import java.util.Scanner;

//TIP 要<b>运行</b>代码，请按 <shortcut actionId="Run"/> 或
// 点击装订区域中的 <icon src="AllIcons.Actions.Execute"/> 图标。
public class Main {
    public static void Swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    public static void Slsort(int[] a,int p,int r){
        for(int i = p + 1;i <= r;i++){
            int index = i;
            for(int j = i + 1;j <= r;j++){
                if(a[j] < a[index]){
                    index  = j;
                }
            }
            Swap(a,i,index);
        }
    }
    public static int Partition(int[] array,int l,int r,int x){
        Swap(array,r,x);
        int j = l;
        int i = l;
        int pivot = r;
        while(j < pivot){
            if(array[j] < array[pivot]){
                Swap(array,i,j);
                i++;
                j++;
            }
            if(array[j] > array[pivot]){
                j++;
            }
        }
        Swap(array,i,pivot);
        return i;
    }
    public static int SearchMid(int[] a,int l,int r){
        int[] b = new int[r - l + 1];
        for(int i = l;i <= r;i++){ //数组a是从l~r，b不是
            b[i - l] = a[i];
        }
        Slsort(b,0,r - l);
        for (int i = l; i <= r; ++i)
        {
            if (a[i] == b[(r - l + 1) / 2])
            {
                return i; //返回的是a里面的中位数下标
            }
        }
        return 0;
    }
  
   public static int select(int[] a, int l, int r, int k) {
       if (r - l + 1 <= 5) {
           Slsort(a, l, r);
           return a[l + k - 1]; // 返回第k小的元素
       }
       // 将数组分成若干组，每组5个元素
       for (int i = 0; i < (r - l + 1) / 5; i++) {
           int left = l + 5 * i; // 当前组的左边界
           int right = Math.min(l + 5 * i + 4, r); // 当前组的右边界
           int mid = SearchMid(a, left, right); // 找到当前组的中位数
           Swap(a, mid, l + i);
       }
       // 对中位数组成的新数组进行递归调用select
       int pivot = select(a, l, l + (r - l + 1) / 5 - 1, (r - l + 6) / 10);
       // 根据pivot进行分区
       int i = Partition(a, l, r, pivot);
       int len = i - l + 1;
       if (k <= len) {
           return select(a, l, i, k);
       } else {
           return select(a, i + 1, r, k - len);
       }
   }

    public static void main(String[] args) {
        System.out.print("请输入你你想要找第k小的数在这个数组中");
        Scanner sc = new Scanner(System.in);
        int k = sc.nextInt();
        int[] a = { 9, 12,15,11, 13, 3, 1, 8, 14,4, 6, 5, 7, 2
        };
        int n = select(a,0,a.length - 1,k);
        System.out.printf("第%d小的数是%d",k,n);
    }
}