很久之前，自己看着尚硅谷的老师的数据结构与算法这门课程的视频，学了这几大排序算法，最近又碰到了排序，于是就想着整理一下，希望对大家有所帮助，谢谢阅览。
1.冒泡排序
冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻的元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底的水泡一样逐渐向上冒。
优化：
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。
public static void bubbleSort(int[] arr) {
// 用于交换的临时变量
int temp = 0;
//优化：用于标识是否交换了，可以提前结束交换，而不必做无用的比较
boolean flag = false;
// 外层for循环是表示比较的趟数
for (int i = 0; i < arr.length - 1; i++) {
// 内层的for循环是表示该趟比较的次数
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;
}
}
if(flag == false){
break;
}else{
//重置，进行下一次判断
flag = false;
}
}
}2.选择排序
选择排序(Select Sorting)也是-种简单的排序方法。它的基本思想是:第-次从arr[0]-arr[n-1]中选取最小值,与arr[0]交换，第二次从arr[1]-arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]-arr[n-1]中选取最小值，与arr[2]交换，…，第i次从arr[i-1]-arr[n-1]中选取最小值，与arr[i-1]交换，…， 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。
public static void selectSort(int[] arr) {
int min = 0;
int minIndex = 0;
// 比较趟数
for (int i = 0; i < arr.length - 1; i++) {
// 假定第下标为i的就是最小值
min = arr[i];
minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
// 找最小值
if (min > arr[j]) {
min = arr[j];
minIndex = j;
}
}
// 将最小值，放在arr[0],即交换
if (minIndex != i) {
arr[minIndex] = arr[i];
arr[i] = min;
}
}
}3.插入排序
插入排序( Insertion Sorting)的基本思想是:把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。
public static void insertSort(int[] arr) {
int insertVal = 0;// 待插入的元素
int insertIndex = 0;// 待比较元素的下标
for (int i = 1; i < arr.length; i++) {
insertVal = arr[i];
insertIndex = i - 1;
while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
arr[insertIndex + 1] = arr[insertIndex];
// 先向前看一下是否还有比待插入元素小的
insertIndex -= 1;
}
// 走到这里，说明已经找到了待插入元素的插入位置
arr[insertIndex + 1] = insertVal;
}
}4.希尔排序
希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序;随着增量逐渐减少，每组包含的关键词越来越多，当增量减至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;
}
}
}
}
}5.快速排序
快速排序(Quicksort)是对冒泡排序的一种改进。基本思想是:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列.
public static void quickSort(int[] arr, int left, int right) {
int l = left;// 左下标
int r = right;// 右下标
int pivot = arr[(left + right) / 2];// 中轴数
int temp = 0;// 辅助交换数
// 左边比pivot小，右边比pviot大
while (l < r) {
while (arr[l] < pivot) {
l += 1;
}
while (arr[r] > pivot) {
r -= 1;
}
// 交换
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
// 全部交换完成
if (l >= r) {
break;
}
if (arr[l] == pivot) {
r -= 1;
}
if (arr[r] == pivot) {
l += 1;
}
}
// 防止栈溢出，开始下一次左右两边的各自排序
// 使得左边的左下标，变成右边的左下标
// 右边的右下标，变成左边的右下标
if (l == r) {
l += 1;
r -= 1;
}
if (left < r) {
quickSort(arr, left, r);
}
if (l < right) {
quickSort(arr, l, right);
}
}6.归并排序
归并排序(Merge Sort)是利用归并的思想实现的排序方法，该算法采用经典的分治( divide- and conquer)策略(分治法将问题分(divide)成一些小 的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在-起，即分而治之)。
// 分+和的方法
public static void mergeSort(int[] arr, int left, int right, int[] temp) {
if (left < right) {
int mid = (left + right) / 2;
// 向左递归进行分解
mergeSort(arr, left, mid, temp);
// 向右递归进行分解
mergeSort(arr, mid + 1, right, temp);
// 合并
merge(arr, left, mid, right, temp);
}
}
/**
*
* @Description 合并的方法
* @author JavaDeng
* @param arr 排序的数组
* @param left 左边索引
* @param mid 中间索引
* @param right 右边索引
* @param temp 辅助数组
*/
public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
int i = left;// 初始化i,左边有序序列的初始索引
int j = mid + 1;// 初始化j,右边有序序列的初始索引
int t = 0;// temp数组的下标
// （一）
// 先把左右两边（有序）的数据按照规则填充到temp数组
// 直到左右两边的有序序列，有一边处理完毕为止
while (i <= mid && j <= right) {
// 如果左边的有序序列的当前元素，小于右边有序序列的当前元素
// 即将左边的当前元素，填充到temp素组
// 然后各自的下标向后移
if (arr[i] <= arr[j]) {
temp[t] = arr[i];
t += 1;
i += 1;
} else {// 反之
temp[t] = arr[j];
t += 1;
j += 1;
}
}
// （二）
// 把有剩余数据的一边的数据依次全部填充到temp数组
while (i <= mid) {// 左边有剩余
temp[t] = arr[i];
t += 1;
i += 1;
}
while (j <= right) {// 右边有剩余
temp[t] = arr[j];
t += 1;
j += 1;
}
// （三）
// 将temp数组拷贝到arr数组中
// 注意不是每次都要拷贝所有的元素
t = 0;
int tempLeft = left;
while (tempLeft <= right) {
arr[tempLeft] = temp[t];
tempLeft += 1;
t += 1;
}
}7.基数排序（桶排序）
基数排序(radix sort) 属于“分配式排序”(distribution sort) ，又称“桶子法” ( bucket sort) 或bin sort, 顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用。它是这样实现的:将整数按位数切割成不同的数字，然后按每个位数分别比较。将所有待比较数值统一为同样的数位长度,数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高 位排序完成以后，数列就变成一个有序序列。
public static void radixSort(int[] arr) {
// 1.得到数组的最大数的位数
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
// 得到最大数是几位
int maxLength = (max + "").length();
// 定义一个二维数组，表示10个桶，每一个桶就是一个一维数组
// 说明
// 1.二维数组包含10个一维数组
// 2.为了防止在放入数的时候，数据溢出，则每一个桶的大小定为arr.length
// 3.基数排序时使用空间换时间的经典算法
int[][] bucket = new int[10][arr.length];
// 为了记录每个桶中，实际存放了多少个数据，我们定义一个一维数组来记录各个桶的每次存放数据的个数
// 可以这样理解
// 比如：bucketElementCounts[0],记录的就是bucket[0]桶的放入数据个数
int[] bucketElementCounts = new int[10];
for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
// 针对每一个元素进行排序处理
for (int j = 0; j < arr.length; j++) {
// 取出每个元素的对应位的值
int digitOfElement = arr[j] / n % 10;
// 放入对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
// 按照这个桶的顺序（一维数组的下标依次取出数据，放入原来数组）
int index = 0;
for (int k = 0; k < bucket.length; k++) {
// 如果桶中有元素，我们才放入原来的数组中
if (bucketElementCounts[k] != 0) {
for (int l = 0; l < bucketElementCounts[k]; l++) {
arr[index++] = bucket[k][l];
}
}
// 每进行下一轮处理时都要将bucketElementCounts[k]清0
bucketElementCounts[k] = 0;
}
System.out.println("第" + (i + 1) + "轮，对应的数据排序处理arr="
+ Arrays.toString(arr));
}
}
