六大基础排序（冒泡，插入，选择，希尔，快速，归并）——Java版

import java.util.Scanner;

public class Sort_Collection {
    static Scanner sc = new Scanner(System.in);
    static int i,j,k,l,temp;
    public static void main(String[] args) {
        int n,option;
        while(true){
            System.out.print("请输入数组个数：");
            n = sc.nextInt();
            int[] array = new int[n];
            System.out.print("请输入数组数据：");
            for(i = 0 ; i < n ; i++)  array[i] = sc.nextInt();
            Menu();
            System.out.print("请输入排序选项：");
            option = sc.nextInt();
            switch(option){
                case 1 -> bubble_sort(array);
                case 2 -> selective_sort(array);
                case 3 -> insertion_sort(array);
                case 4 -> {
                    System.out.println("排序过程：");
                    quick_sort(array , 0 , n-1);
                    System.out.println("思路：找到基准点，比基准点小的数据放到基准点左边，比基准点大的放到基准点的右边，再分别对基准点左边和右边的数据进行内部排序，快速排序速度比较快，所以多出了许多无效数据（适合数据量大且乱序）");
                    System.out.println("\n" + "\n");
                }
                case 5 -> hill_sort(array);
                case 6 -> {
                    sort_array(array);
                    System.out.println("思路：分而治之，把数组依次分组，然后组内排序");
                    System.out.println("\n" + "\n");
                }
                case 7 -> {
                    System.out.println("退出成功！");
                    System.exit(0);
                }
                default -> System.out.println("请输入正确的选项！");
            }
        }
    }

    public static void Menu(){
        System.out.println("------------------------递增排序----------------------------------");
        System.out.println("                      ①冒泡排序（时间复杂度：O（n²）");
        System.out.println("                      ②选择排序（时间复杂度：O（n²）");
        System.out.println("                      ③插入排序（时间复杂度：O（n²）");
        System.out.println("                      ④快速排序时间复杂度：O（n²）或O(N * logN)");
        System.out.println("                      ⑤希尔排序（时间复杂度：O（n²）");
        System.out.println("                      ⑥归并排序（时间复杂度：O(N * logN)）");
        System.out.println("                      ⑦退出");
        System.out.println("--------------------------------------------------------------");
    }

    public static void bubble_sort(int[] array){
        System.out.println("排序过程：");
        for(i = array.length - 1 ; i >= 0 ; i--){
            for(j = 0 ; j < i ; j++){
                if(array[j] > array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
            for(k = 0 ; k < array.length ; k++)  System.out.print(array[k] + " ");
            System.out.println();
        }
        System.out.println("思路：依次将最大的数据放到数组末尾，然后不管它，再接着把未处理数据中的最大数字放到数组后端，以此类推");
        System.out.println("\n" + "\n");
    }

    public static void selective_sort(int[] array){
        System.out.println("排序过程：");
        int min_index;
        for(i = 0 ; i < array.length - 1 ; i++){
            min_index = i;
            for(j =  i + 1 ; j < array.length ; j++){
                if(array[j] < array[min_index])  min_index = j;
            }
            if(i != min_index){
                temp = array[i];
                array[i] = array[min_index];
                array[min_index] = temp;
            }
            for(k = 0 ; k < array.length ; k++)  System.out.print(array[k] + " ");
            System.out.println();
        }
        System.out.println("思路：找打最小数与索引调换位置，将合适的数放到合适的位置");
        System.out.println("\n" + "\n");
    }

    public static void insertion_sort(int[] array){
        System.out.println("排序过程：");
        for(i = 1 ; i < array.length ; i++){
            for(j = i ; j > 0 ; j--){
                if(array[j-1] > array[j]){
                    temp = array[j-1];
                    array[j-1] = array[j];
                    array[j] = temp;
                }
            }
            for(k = 0 ; k < array.length ; k++)  System.out.print(array[k] + " ");
            System.out.println();
        }
        System.out.println("思路：将未排序的数字与已排序的数字进行倒序比较，若小于已排序的数字则调换位置");
        System.out.println();
    }

    public static void quick_sort(int[] array , int low , int high){
        if(low < high){
            int point = partition(array , low , high);    //寻找基准点
            quick_sort(array , 0 , point-1);    //对基准点左边进行排序
            quick_sort(array , point+1 , high);    //对基准点的右边进行排序
        }
    }
    public static int partition(int[] array , int low , int high){
        int point = array[low];    //确认基准点
        while(low < high){
            while(low < high && array[high] >= point)  high--;    //比基准点大的数据放到基准点的右边
            array[low] = array[high];
            while(low < high && array[low] <= point)  low++;    //比基准点小的数据放到基准点的右边
            array[high] = array[low];
        }
        array[low] = point;    //和基准点的主句进行交换
        for(i = 0 ; i < array.length ; i++)  System.out.print(array[i] + " ");    //打印交换过程
        System.out.println();
        return low;    //返回目前基准点所在的位置
    }

    public static void hill_sort(int[] array){
        int length,h;
        length = array.length;  h = 1;
        while(h < length/2)  h = h * 2 + 1;    //确认增量值
        while(h >= 1){
            for(i = h ; i < array.length ; i++){
                for(j = i ; j >= h ; j-= h){
                    if(array[j-h] > array[j]){    //交换与增量值所对应的数据
                        temp = array[j-h];
                        array[j-h] = array[j];
                        array[j] = temp;
                    }
                }
            }
            h /= 2;
            for(k = 0 ; k < array.length ; k++)  System.out.print(array[k] + " ");    //打印交换过程的数据
            System.out.println();
        }
        System.out.println("思路：先确定一个增量值（比如3），然后从头开始与增量值所在的位置的数据进行对比交换数据（如0索引的增量位为4索引）");
        System.out.println("\n" + "\n");
    }

    public static void sort_array(int[] array){
        int length = array.length;
        int[] num = new int[length];
        merge_sort(array , num , 0 , length-1);
    }
    public static void merge_sort(int[] array  ,int[] num , int left , int right){
        if(left == right)  return;    //直接结束
        int middle = left + (right - left) / 2;    //防止数据越界
        merge_sort(array , num , left , middle);    //树的左边
        merge_sort(array , num , middle+1 , right);    //树的右边

        //合并区间
        for(i = left ; i <= right ; i++)  num[i] = array[i];
        i = left;  j = middle + 1;
        for(k = left ; k <= right ; k++){    //k为插入的位置
            if(i == middle + 1){
                array[k] = num[j];
                j++;
            }
            else if(j == right + 1){
                array[k] = num[i];
                i++;
            }
            else if(num[i] < num[j]){
                array[k] = num[i];
                i++;
            }
            else{
                array[k] = num[j];
                j++;
            }
            for(l = 0 ; l < array.length ; l++)  System.out.print(array[l] + " ");    //打印交换过程的数据
            System.out.println();
        }
    }
}