啊哈之排练习

桶排序

冒泡排序

快速排序

package com.company.algorithm.A20211126;

import java.io.FileInputStream;
import java.util.Arrays;
import java.util.Scanner;

public class Sort {

    // 低配版桶排序
    private static void sortBySampleBucket() {
        int[] arr = {5,3,5,2,8}; // 已知
        //1获取最大数字
        int max = 0;
        for (int it : arr)  if(it > max) max = it;
        //2创建一个数组容器
        int[] book = new int[max+1];
        //3开始计数
        for (int i = 0; i < arr.length; i++) {
            book[arr[i]]++;
        }
        //4输出
        for (int i = max; i >= 0 ; i--) {
            if(book[i] == 0) continue;
            for (int j = 0; j < book[i]; j++) {
                System.out.print(i+" ");
            }
        }
    }
    // 以上存在问题 1. 浪费空间，2 无法对对象排序，也就是只对int进行的

    private static void bubbleSort() throws Exception {
        System.setIn(new FileInputStream("D:/data.txt"));
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();//n表示接下来会输入n个数
        int[] arr = new int[n+1];
        for (int i = 1; i <= n; i++) {
            arr[i] = sc.nextInt();
        }

        // 为什么是1到n-1呢，n个数比较n-1次就可以确定1个数的位置
        for (int i = 1; i < n-1; i++) {
            //为什么是n-i呢，前面i个数已经位置排好了,不需要多余的比较了（排到后面了）
            for (int j = 1; j < n-i; j++) {
                if(arr[i] < arr[j]) {
                    int t = arr[j];
                    arr[j] = arr[i];
                    arr[i] = t;
                }
            }
        }

        System.out.println(Arrays.toString(arr));

        // 如果是对象类型，只需要把arr改成obj[]
    }

    //快排是基于一种二分法的思想，每次将基准数归位。
    private static void quicksort() {
        int[] arr = {6,1,2,7,9,3,4,5,10,8};
        quicksortMethod(arr, 0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

    private static void quicksortMethod(int[] arr, int left, int right) {
        if(left > right) return;
        int i = left, j = right, t;
        int base = arr[left];
        while (i != j) {
            // 因为以左边为基准，先从右往左找,找到第一个小于基准的数停下
            while (arr[j] >= base && i < j) {
                j--;
            }
            //再从左边往右边找,找到第一个大于基准的数停下来
            while (arr[i] <= base && i < j) {
                i++;
            }

            //如果没有相遇交换位置
            if(i < j) {
                t = arr[j]; // 交换位置的临时变量
                arr[j] = arr[i];
                arr[i] = t;
            }
        }

        // 在相遇的位置将基准归位
        arr[left] = arr[i]; // 相遇的位置放到最左边
        arr[i] = base;// 左边最基准的值放到相遇的位置

        // 左右两次 循环一样的方法
        quicksortMethod(arr, left, i-1);
        quicksortMethod(arr, i+1, right);
        //事实上每一轮都是为了基准数归为，时间复杂度最差的效率也是 n方，但是平均是 nlogn
    }

    public static void main(String[] args) throws Exception{
        //sortBySampleBucket();
//        bubbleSort();
        quicksort();
    }
}