四大高级排序

快速排序

原理

1.先从数据序列中选一个元素，并将序列中所有比该元素小的元素都放到它的右边或左边，再对左右两边分别用同样的方法处之直到每一个待处理的序列的长度为1，处理结束。
2. 快排有一个特别需要注意的点，就是快排应该先从右边查找需要找的数

代码实现

public static void main(String[] args) {
        int[] arr = new int[]{1,4,6,2,8};
        quick_sort(arr, 0, arr.length - 1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    //我对快排的理解就是找一个基准数字，用两个指针对两边的数字进行交换
    public static void quick_sort(int[] a, int left, int right) {
        
        if (a == null || a.length == 0) return;

        //递归的终结条件
        if (left > right) {
            return;
        }
        //1.定义两个指针，一个指向第一个，一个指向右边巅峰
        int i = left;
        int j = right;
        //2.定义基准数
        int temp = a[left];
        //3.进行查找，先从右边开始
        while (i != j) {
            //3.1 先查找右边，切记!!!!!!!!!
            //不先查找右边的话{6,1,2,3,4,5,7,8}这种情况不好搞
            while (i < j && a[j] >= temp) {
                j--;
            }
            //3.2再查找左边，切记
            //等号要加上，要不然的话遇到相同的值就只能卡住了
            while (i < j && a[i] <= temp) {
                i++;
            }
            //4.进行交换
            if (i < j) {
                int m = a[i];
                a[i] = a[j];
                a[j] = m;
            }
        }
        //5.对基准值和最后指针停留的位置进行交换
        int n = a[i];
        a[i] = a[left];
        a[left] = n;

        //6.递归，对两个数组进行排序
        quick_sort(a, left, j - 1);
        quick_sort(a, j + 1, right);
    }

归并排序

原理

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

代码实现

	public static void main(String[] args) {
	  int[] arr = {1, 4, 2, 7, 4};
	  sort(arr);
	  for (int i : arr) {
	      System.out.print(i + "\t");
	  }
	}
	
	public static void sort(int[] arr){
	  int[] tmp = new int[arr.length];
	  int left = 0 ;
	  int right = arr.length - 1 ;
	  sortMerge(arr , left , right , tmp);
	}
	
	public static void sortMerge(int[] arr,int left,int right,int[] tmp){
	  if (left < right){
	      int mid = (left + right) / 2;
	      sortMerge(arr,left,mid,tmp);
	      sortMerge(arr,mid + 1,right,tmp);
	      sortMerge(arr,left,mid,right,tmp);
	  }
	}
	
	private static void sortMerge(int[] arr, int left, int mid, int right, int[] tmp) {
	
	  //1.定义两个指针，一个指向左边数组，一个指向右边数组
	  int i = left;
	  int j = mid + 1;
	  int t = 0;
	
	  //2.循环，对数组进行处理
	  while (i <= mid && j<= right){
	      if(arr[i] <= arr[j]){
	          tmp[t++] = arr[i++];
	      }else {
	          tmp[t++] = arr[j++];
	      }
	  }
	
	  //经过上面的循环，如果i<mid的话，证明j > right
	  while (i <= mid){
	      tmp[t++] = arr[i++];
	  }
	
	  while (j < right){
	      tmp[t++] = arr[j++];
	  }
	
	  //把t置零，把tmp数组里面的值赋给arr数组
	  t = 0;
	  while (left < right){
	      arr[left++] = tmp[t++];
	  }
}

堆排序

原理

利用java里面自带的PriorityQueue来实现，贼简单

代码实现

 //堆排序
    public static void main(String[] args) {
        int[] arr = {1, 4, 2, 7, 4};
        heapSort(arr);
        for (int i : arr) {
            System.out.print(i + "\t");
        }
    }
    

    public static void heapSort(int[] arr){

        //用来在最后添加值
        int t = 0;
        
        //小顶堆
        Queue<Integer> queue = new PriorityQueue<>((a,b) -> a - b);

        for (int i = 0; i < arr.length; i++) {
            queue.add(arr[i]);
        }
        
        while (!queue.isEmpty()){
            arr[t++] = queue.poll();
        }
    }

基数排序

原理

基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。

代码实现

public static void main(String[] args) throws Exception {
        int[]data = {73, 22, 93, 43, 55, 14, 28, 65, 39, 81, 33, 100};
        countSort(data, data.length);

        for(int i = 0; i < data.length; i++)
        {
            System.out.print(data[i] + " ");
        }
    }


    //计数排序
    public static void countSort(int[] a,int len) throws Exception {
        if (a == null || a.length == 0) throw new Exception("此数组为空，无法排序");
        int k = 0;
        //找到最大数字的最大位数
        int maxBit = findMaxBit(a);
        //用来保存数值
        int[][] tmpArr = new int[10][a.length];
        //用来计数
        int[] count = new int[10];

        for (int i = 0;i < maxBit;i++){
            for (int j = 0;j < len;j++){
                int index = (int) (a[j] / Math.pow(10,i) % 10); //求出当前位的数字
                //根据index进行排序
                tmpArr[index][count[index]] = a[j];
                count[index]++;
            }
            //对排好序的内容进行重新赋值
            for (int m = 0;m < 10;m++){
                if (count[m] != 0) {
                    for (int n = 0; n < count[m]; n++) {
                        a[k] = tmpArr[m][n];
                        k++;
                    }
                    //把每位的count归零
                    count[m] = 0;
                }
            }
            //把每一波的k归零
            k = 0;
        }
    }

    //找到最大位数的数字
    public static int findMaxBit(int[] a){
        int m = 0;
        for (int i = 0; i < a.length; i++) {
            if(String.valueOf(a[i]).length() > m){
                m = String.valueOf(a[i]).length();
            }
        }
        return m;
    }