数据结构排序算法大合集：快排、归并、基数、希尔等

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int [] arr = {1, 2, 3, 4, 5, 6};
        bubble(arr);
        System.out.println(Arrays.toString(arr));

    }
    //冒泡排序
    public static void bubble(int [] arr){
        int temp = 0;
        boolean flag = false;

        for(int i = 0; i < arr.length; i++){
            for(int j = 0; j < arr.length - 1; j++){
                if(arr[j] > arr[j + 1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if(!flag){
                break;
            }
        }
    }
}


    //选择排序：没次从无序数列中选一个最小的，放到有序数列的后面
    public static void selectSort(int [] arr){
        int minIndex;
        int minValue;
        int temp = 0;

        for(int i = 0; i < arr.length; i++){
            minIndex = i;//每次都默认最小值是无序数列的第一个数
            minValue = arr[i];

            for(int j = i + 1; j < arr.length; j++){
                if(arr[j] < minValue){
                    minIndex = j;
                    minValue = arr[j];
                }
            }

            //交换最小数,如果最小数就是第一个，就不交换
            if(minIndex == i){
                continue;
            }
            temp = arr[i];
            arr[i] = minValue;
            arr[minIndex] = temp;
        }
    }
//插入排序，有序列表初始化有一个元素
    //扫描无序列表，在有序数列中找到要插入的位置
    public static void insertSort(int [] arr){
        int temp = 0;
        for(int i = 0; i < arr.length - 1; i++){
            int j = i;
            temp = arr[j + 1];

            while (j >= 0){
                if(arr[j] > temp){
                    arr[j + 1] = arr[j];
                    j--;
                } else {
                    break;
                }
            }

            //找到要插入的位置 j + 1
            arr[j + 1] = temp;
        }
    }
//快速排序
    public static void quickSort(int [] arr, int left, int right){
        int mid = (left + right) / 2;//基准
        int i = left;
        int j = right;
        int temp = 0;

        while (i < j){
            //找到左边第一个大于等于基准值的数，停下，准备交换
            while (arr[i] < arr[mid]){
                i++;
            }
            //找到右边第一个小于等于基准值的数，停下，准备交换
            while (arr[j] > arr[mid]){
                j--;
            }

            //停下的时候,判断是否需要交换
            if(i >= j){
                break;
            }

            //否则，i < j ，交换
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;

            //交换完之后,需要判断交换后的值与基准值的比较
            //表示arr[j] 不用参与判断了
            if(arr[i] == arr[mid]){
                j--;
            }

            //表示arr[i] 不用判断了
            if(arr[j] == arr[mid]){
                i++;
            }
        }

        if(i == j){
            i ++;
            j--;
        }

        //递归
        if(left < j){
            quickSort(arr,left,j);
        }

        if(right > i){
            quickSort(arr,i,right);
        }
    }
  public static void mergeSort(int [] arr, int left, int right, int [] temp){
        //分到不能再分
        int mid = (left + right) / 2;

        if (left < right){
            mergeSort(arr,left,mid,temp);
            mergeSort(arr,mid + 1, right,temp);

            //合并
            merge(arr,left,mid, right,temp);
        }
    }

    //mid为两个有序序列的分割点
    public static void merge(int [] arr, int left, int mid, int right, int [] temp ){
        int i = left;//左边有序序列的开始下标
        int j = mid + 1;//右边有序序列的开始下标
        int t = 0;

        //合并两个有序序列
        while (i <= mid && j <= right){
            if(arr[i] <= arr[j]){
                temp[t] = arr[i];
                i += 1;
            } else {
                temp[t] = arr[j];
                j += 1;
            }
            t += 1;
        }

        //
        while (i <= mid){
            temp[t] = arr[i];
            i += 1;
            t += 1;
        }

        while (j <= right){
            temp[t] = arr[j];
            j += 1;
            t += 1;
        }

        //把合并之后有序的temp数组的数据移到arr中
        //[left,right]
        int tempLeft = left;
        t = 0;

        while (tempLeft <= right){
            arr[tempLeft] = temp[t];
            tempLeft += 1;
            t += 1;
        }

    }
//交换法，效率低
    public static void shellSort(int [] arr){
        int temp = 0;
        for(int gap = arr.length / 2; gap > 0; gap /= 2){
            for(int i = gap; i < arr.length; i++){
                for(int j = i - gap; j >= 0; j -= gap){
                    if(arr[j] > arr[j + gap]){
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
        }
    }

    //移位法,效率高-->第三层循环使用插入排序的方法
    public static void shellSort01(int []arr){
        int tmp = 0;
        for(int gap = arr.length / 2; gap > 0; gap /= 2){
            for(int i = gap; i < arr.length; i++){
                int j = i;
                tmp = arr[j];//记录待插入的值

                if(arr[j] < arr[j - gap]){
                    while (j - gap >= 0 && tmp < arr[j - gap]){
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }
                    //
                    arr[j] = tmp;
                }
            }
        }
    }

public static void radixSort(int [] arr){
        int [][] bucket = new int[10][arr.length];
        int [] bucketCount = new int[10];

        int max = arr[0];
        for(int i = 1; i < arr.length; i++){
            if(arr[i] > max){
                max = arr[i];
            }
        }
        //得到最大数的位数
        int maxLength = (""+max).length();

        //把所有的数放入桶中
        int base = 1;//用来得到每位上的数
        for(int i = 0; i < maxLength; base *= 10,i++){
            for(int k = 0; k < arr.length; k++){
                int digit = (arr[k] / base) % 10;
                bucket[digit][bucketCount[digit]] = arr[k];
                bucketCount[digit]++;//第digit个桶中存放的元素加1
            }
            //退出循环后，所有元素已经放入桶中
            //按顺序从桶中取出所有元素
            int index = 0;
            for(int j = 0; j < bucket.length; j++){

                if(bucketCount[j] != 0){
                    for(int h = 0; h < bucketCount[j]; h++){
                        arr[index] = bucket[j][h];
                        index ++;
                    }
                    //取完之后，设置桶中存放元素为0
                    bucketCount[j] = 0;
                }
            }
        }

    }