可以参考：https://www.cnblogs.com/onepixel/articles/7674659.html
这里写主要是为了自己总结和加深印象
1、冒泡排序（Bubble Sort）
> 说明
从第一位开始，循环比较相连的两位数，假如前一位数大于后一位数，则交换位置，这样第一遍循环 【数据的长度-1 】次之后，就把最大值放到最后的位置，总共循环 【数据的长度-1】 遍之后，则整个乱序变成正
> 算法复杂度
| 最优复杂度 | 最差复杂度 | 平均复杂度 | 空间复杂度 |
|---|---|---|---|
| O(n) | O(n^2) | O(n^2) | O(1) |
> 代码实现
public class BubbleSort {
/**
* 等待排序的数组(乱序)
*/
static int[] DISORDER_ARRAY = new int[]{34, 56, 78, 98, 1, 23, 3, 8, 99, 66, 28, 16};
/**
* 等待排序的数组(倒序)
*/
static int[] DESC_ARRAY = new int[]{99, 98, 78, 66, 56, 34, 28, 23, 16, 8, 3, 1};
/**
* 入口函数
*
* @param args 参数
*/
public static void main(String[] args) {
// BubbleSort1();
BubbleSort2();
}
/**
* 冒泡排序第一种，把最大值移到最后面
*/
private static void BubbleSort1() {
// 描述：length 为数据的长度， n 为遍数，k 为每一遍对比次数
int length = DISORDER_ARRAY.length;
// 总共循环的遍数（length - 1遍）
for (int n = 0; n < length - 1; n++) {
// 每遍对比的次数 length - n - 1
for (int k = 0; k < length - n - 1; k++) {
// 升序排序
if (DISORDER_ARRAY[k] > DISORDER_ARRAY[k + 1]) {
int temp = DISORDER_ARRAY[k + 1];
DISORDER_ARRAY[k + 1] = DISORDER_ARRAY[k];
DISORDER_ARRAY[k] = temp;
}
}
StringBuilder stringBuilder = new StringBuilder();
for (Integer integer : DISORDER_ARRAY) {
if (stringBuilder.length() > 0) {
stringBuilder.append(", ");
}
stringBuilder.append(integer);
}
System.out.println(stringBuilder.toString());
}
}
/**
* 冒泡排序第一种，比较两个值，把最小值交换到对比的值
*/
private static void BubbleSort2() {
// 描述：length 为数据的长度， n 为遍数，k 为每一遍对比次数
int length = DISORDER_ARRAY.length;
// 总共循环的遍数（length - 1遍）
for (int n = 0; n < length - 1; n++) {
// 每遍对比的次数 length - n - 1
for (int k = n + 1; k < length; k++) {
// 升序排序
if (DISORDER_ARRAY[n] > DISORDER_ARRAY[k]) {
int temp = DISORDER_ARRAY[k];
DISORDER_ARRAY[k] = DISORDER_ARRAY[n];
DISORDER_ARRAY[n] = temp;
}
}
StringBuilder stringBuilder = new StringBuilder();
for (Integer integer : DISORDER_ARRAY) {
if (stringBuilder.length() > 0) {
stringBuilder.append(", ");
}
stringBuilder.append(integer);
}
System.out.println(stringBuilder.toString());
}
}
}2、选择排序（Selection Sort）
> 说明
从第一位开始，用其后面的数值和其比较，若是比它小则记录下索引位置，然后后面的比较用当前索引位置的值和后面的值比较，直到比较结束找到最小的值，然后和起始用于比较位置的值进行交换位置。然后从第2、3、4、.....位开始，重复上面的操作，直到结束。
> 复杂度
| 最优复杂度 | 最差复杂度 | 平均复杂度 | 空间复杂度 |
|---|---|---|---|
| O(n) | O(n^2) | O(n^2) | O(1) |
> 代码实现
public class SelectionSort {
/**
* 等待排序的数组(乱序)
*/
static int[] DISORDER_ARRAY = new int[]{34, 56, 78, 98, 1, 23, 3, 8, 99, 66, 28, 16};
/**
* 等待排序的数组(倒序)
*/
static int[] DESC_ARRAY = new int[]{99, 98, 78, 66, 56, 34, 28, 23, 16, 8, 3, 1};
/**
* 入口函数
*
* @param args 参数
*/
public static void main(String[] args) {
// 逻辑：从第一位开始，分别用后面的数据和当前的值进行比较，记录最小的值，然后把当前的值和最小值进行交换
// 循环 长度-1 遍
int length = DISORDER_ARRAY.length;
for (int i = 0; i < length - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < length; j++) {
// 用最小值和之前的值比较
if (DISORDER_ARRAY[minIndex] > DISORDER_ARRAY[j]) {
minIndex = j;
}
}
if (i != minIndex) {
int temp = DISORDER_ARRAY[minIndex];
DISORDER_ARRAY[minIndex] = DISORDER_ARRAY[i];
DISORDER_ARRAY[i] = temp;
}
StringBuilder stringBuilder = new StringBuilder();
for (Integer integer : DISORDER_ARRAY) {
if (stringBuilder.length() > 0) {
stringBuilder.append(", ");
}
stringBuilder.append(integer);
}
System.out.println(stringBuilder.toString());
}
}
}3、插入排序（Insertion Sort）
> 说明
> 复杂度
> 代码实现
4、希尔排序（Shell Sort）
5、归并排序（Merge Sort）
6、快速排序（Quick Sort）
7、堆排序（Heap Sort）
8、计数排序（Counting Sort）
9、桶排序（Bucket Sort）
10、基数排序（Radix Sort）