（java版）排序算法----【冒泡，选择，插入，希尔，快速排序，归并排序，基数排序，堆排序】超详细~~

目录

冒泡排序(BubbleSort)：

代码详解：

 冒泡排序的优化：

 选择排序(SelectSort)：

代码详解：

 插入排序（InsertSort）：

代码详解：

 希尔排序(ShellSort)：

 法一（交换法）代码详解：

 法二（移位法-->插入排序的优化）代码详解：

快速排序（QuickSort）： 

代码详解：

 归并排序（MergetSort）：

代码详解：

 基数排序（RadixSort）：

代码详解：

堆排序：

最后，一张图概括： 

---

冒泡排序(BubbleSort)：

冒泡排序（BubbleSort）的基本思路：通过对待排序从前往后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前往后移动，较小的往上挪动，就像水底下的气泡一样逐渐向上冒。

图解：

代码详解：

public class BubbleSort {
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);

        int[] arr=new int[5];//假设测试案例只有五个数字
        System.out.print("请输入要排序的数组：");
        for(int i=0;i<5;i++){
            arr[i]=sc.nextInt();
        }

        bubblesort(arr);
        System.out.println();
        System.out.print("请输出排序好的数组："+Arrays.toString(arr));

    }
    public static void bubblesort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
            System.out.printf("第%d趟排序后的数组",i+1);//展示每次冒泡排序的过程
            System.out.println(Arrays.toString(arr));//将数组转化为字符串的形式输出
        }
    }
}

运行结果：（通过运行结果来展示“气泡”向上挪动的过程，较大的数逐渐沉底）

 冒泡排序的优化：

因为排序的过程中，各个元素不断接近自己要排好时所对应的位置，如果一趟比较下来没有进行交换，就说明序列有序。通过设置一个标志flag判断元素是否进行过交换，从而减少不必要的比较。

优化代码：

// 将前面额冒泡排序算法，封装成一个方法
public static void bubbleSort(int[] arr) {
	// 冒泡排序 的时间复杂度 O(n^2), 自己写出
	int temp = 0; // 临时变量
	boolean flag = false; // 标识变量，表示是否进行过交换
	for (int i = 0; i < arr.length - 1; i++) {

		for (int j = 0; j < arr.length - 1 - i; j++) {
			// 如果前面的数比后面的数大，则交换
			if (arr[j] > arr[j + 1]) {
				flag = true;
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
		//System.out.println("第" + (i + 1) + "趟排序后的数组");
		//System.out.println(Arrays.toString(arr));

		if (!flag) { // 在一趟排序中，一次交换都没有发生过
			break;
		} else {
			flag = false; // 重置flag!!!, 进行下次判断
		}
	}
}

时间复杂度：最坏情况：O(N^2)
      最好情况：O(N)
空间复杂度：O(1)

小结冒泡排序规则

(1) 一共进行 数组的大小-1 次 的循环

(2)每一趟排序的次数在逐渐的减少

(3) 如果我们发现在某趟排序中，没有发生一次交换， 可以提前结束冒泡排序。这个就是优化 

 选择排序(SelectSort)：

选择排序（SelectSort）的基本思路：

1. 选择排序一共有 数组大小 - 1 轮排序

2. 每1轮排序，又是一个循环, 循环的规则(代码)

2.1先假定当前这个数是最小数

2.2 然后和后面的每个数进行比较，如果发现有比当前数更小的数，就重新确定最小数，并得到下标

2.3 当遍历到数组的最后时，就得到本轮最小数和下标

2.4 交换 [代码中再继续说 ]

 图解：

代码详解：

import java.util.*;
public class SelectSort {

    //selectsort排序的方法、
    public static void selectSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            int minIdex=i;//设第一个数为最小，同时将其索引（在数组中的位置）用minIndex表示
            int min=arr[i];//用min记录最小的数
            for(int j=i+1;j<arr.length;j++){
                if(min>arr[j]){
                    min=arr[j];//通过选择将最小的数选出，然后更新min和minIndex
                    minIdex=j;
                }
            }
            arr[minIdex]=arr[i];//将当前位置的数和最小数交换
            arr[i]=min;
            System.out.println("这是第"+i+"次排序，结果是：");//记录排序的过程
            System.out.println(Arrays.toString(arr));
        }
    }
//测试排序
    public static void main(String[] args){
       Scanner sc=new Scanner(System.in);
       int[] arr=new int[5];
        System.out.println("请输入你要排序的数组：");
        for(int i=0;i<5;i++){
            arr[i]=sc.nextInt();
        }
        selectSort(arr);
        System.out.println("排序好后的数组是:");
        for(int i=0;i<5;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

运行结果：（通过运行过程来展示排序过程）