冒泡排序（Bubble Sort）：
基本思想：通过相邻元素的比较和交换，将最大（或最小）的元素逐步"冒泡"到数组的末尾。每一轮比较都会将未排序部分的最大（或最小）元素放到合适位置。
平均时间复杂度：O(n^2)，其中n 是待排序数组的元素个数。在最坏情况下（数组完全逆序）和平均情况下，都需要进行大量的比较和交换操作，时间复杂度为O(n^2)。在最好情况下（数组已经有序），只需要进行n-1 次比较，时间复杂度为O(n)。
举例：
ini
public static void main(String[] args) {
int[] arr = {5, 3, 4, 1};
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 tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
System.out.println(Arrays.toString(arr));
}选择排序（Selection Sort）：
基本思想：每一轮在未排序部分中找到最小（或最大）的元素，然后将其与未排序部分的第一个元素交换位置，逐步将未排序部分缩小。
平均时间复杂度：O(n^2)。无论数组初始状态如何，都需要进行n(n-1)/2 次比较，所以平均和最坏时间复杂度都是O(n^2)，空间复杂度为O(1)。
举例：
ini
public static void main(String[] args) {
int arr[] = {7, 2, 5, 3, 6};
//循环的轮数 数组长度-1
for (int i = 0; i < arr.length - 1; i++) {
//将前面的位置锁定和后面的进行比较，比它小的就进行交换
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
}
System.out.println(Arrays.toString(arr)); //[2, 3, 5, 6, 7]
}插入排序（Insertion Sort）：
基本思想：将一个数据插入到已经排好序的数组中的适当位置。初始时假设第一个元素已经有序，然后从第二个元素开始，依次将每个元素插入到前面已排好序的子数组中的合适位置。
平均时间复杂度：O(n^2)。在最坏情况下（数组完全逆序），时间复杂度为O(n^2)；在最好情况下（数组已经有序），时间复杂度为O(n)；平均情况下时间复杂度为O(n^2)。
举例：
ini
public static void main(String[] args) {
int[] arr = {3, 2, 1, 4, 8};
for (int i = 1; i < arr.length; i++) {
for (int j = i; j > 0; j--) {
if (arr[j] < arr[j - 1]) {
int tmp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = tmp;
} else {
break;
}
}
}
System.out.println(Arrays.toString(arr)); //[1, 2, 3, 4, 8]
}希尔排序（Shell Sort）：
基本思想：是插入排序的改进版本，通过将数组按一定间隔（增量）分组，对每组进行插入排序，随着增量逐渐减小，数组逐渐变得有序，最后增量为 1 时，进行一次普通的插入排序。
平均时间复杂度：其时间复杂度依赖于增量序列的选择，一般在O(n^{1.3}) 左右 ，比O(n^2) 要好，但分析较为复杂。 举例
ini
public static void main(String[] args) {
int[] arr = {5, 3, 1, 6, 22, 2};
int d, i, j;
//d 步长
int n = arr.length; //数组长度
for (d = n / 2; d >= 1; d = d / 2) {
for (i = d; i < n; ++i) {
int tmp = arr[i];
for (j = i; j >= d && arr[j - d] > tmp; j -= d) {
arr[j] = arr[j - d];
}
arr[j] = tmp;
}
}
System.out.println(Arrays.toString(arr));//[1, 2, 3, 5, 6, 22]
}快速排序（Quick Sort）：
基本思想：采用分治思想，选择一个基准元素，将数组分为两部分，左边部分的元素都小于基准元素，右边部分的元素都大于基准元素，然后分别对左右两部分递归地进行快速排序。
平均时间复杂度：O(nlogn)。在平均情况下，每次划分都能将数组大致分成两等份，递归深度为logn，每层操作的时间复杂度为O(n)，所以平均时间复杂度为O(nlogn)。但在最坏情况下（如每次选择的基准都是数组中的最大或最小元素），时间复杂度会退化为O(n^2)。 举例：
scss
public static void quickSort(int[] arr, int left, int right) {
if (left < right) {
int pivotIndex = partition(arr, left, right);
quickSort(arr, left, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, right);
}
}
// 分区函数：选择一个基准元素，将数组分为两部分
private static int partition(int[] arr, int left, int right) {
int pivot = arr[right]; // 选择最右边的元素作为基准
int i = left - 1; // i指向小于基准元素的最后一个元素
// 遍历数组，将小于基准的元素放到左边
for (int j = left; j < right; j++) {
if (arr[j] < pivot) {
i++;
swap(arr, i, j); // 将小于基准的元素交换到左边
}
}
swap(arr, i + 1, right); // 将基准元素放到正确的位置
return i + 1; // 返回基准元素的索引
}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void main(String[] args) {
int[] arr = {5, 33, 4, 1, 22,6};
quickSort(arr, 0, arr.length - 1);
System.out.println(java.util.Arrays.toString(arr));
}归并排序（Merge Sort）：
基本思想：同样采用分治思想，将一个数组不断地分成两半，对每一半分别进行排序，然后将排好序的两半合并起来。
平均时间复杂度：O(nlogn)。无论数组初始状态如何，都需要将数组不断拆分和合并，递归深度为logn，每层操作的时间复杂度为O(n)，所以时间复杂度始终为O(nlogn)。
举例：
scss
public static void main(String[] args) {
int[] arr = {5, 3, 4, 1, 2};
mergeSort(arr, 0, arr.length - 1);
System.out.println(java.util.Arrays.toString(arr));
}
// 归并排序的主方法
public static void mergeSort(int[] arr, int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
mergeSort(arr, left, mid); // 排序左半部分
mergeSort(arr, mid + 1, right); // 排序右半部分
merge(arr, left, mid, right); // 合并两部分
}
}
// 合并两个已排序的部分
public static void merge(int[] arr, int left, int mid, int right) {
// 创建临时数组
int[] temp = new int[right - left + 1];
int i = left; // 左半部分的起始索引
int j = mid + 1; // 右半部分的起始索引
int k = 0; // 临时数组的索引
// 合并两个已排序的部分
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
// 将左半部分剩余的元素添加到临时数组
while (i <= mid) {
temp[k++] = arr[i++];
}
// 将右半部分剩余的元素添加到临时数组
while (j <= right) {
temp[k++] = arr[j++];
}
// 将临时数组中的元素复制回原数组
for (int m = 0; m < temp.length; m++) {
arr[left + m] = temp[m];
}
}堆排序（Heap Sort）：
基本思想：先将数组构建成一个最大堆（或最小堆），然后每次从堆顶取出最大（或最小）元素，将剩余元素重新调整为堆，重复这个过程直到堆为空，从而得到一个有序数组。
平均时间复杂度：O(nlogn)。构建堆的时间复杂度为O(n)，每次调整堆并取出堆顶元素的时间复杂度为O(logn)，一共需要进行n-1 次调整，所以总的时间复杂度为O(nlogn)。
举例：
ini
public static void main(String[] args) {
int[] arr = {5, 3, 4, 1, 2};
heapSort(arr);
System.out.println(java.util.Arrays.toString(arr));
}
// 堆排序
public static void heapSort(int[] arr) {
int n = arr.length;
// 构建最大堆
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}
// 一个个取出元素
for (int i = n - 1; i > 0; i--) {
// 将当前根节点（最大值）与最后一个元素交换
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
// 调整剩余的堆
heapify(arr, i, 0);
}
}
// 调整堆
public static void heapify(int[] arr, int n, int i) {
int largest = i; // 初始化最大值为根节点
int left = 2 * i + 1; // 左子节点
int right = 2 * i + 2; // 右子节点
// 如果左子节点比根节点大
if (left < n && arr[left] > arr[largest]) {
largest = left;
}
// 如果右子节点比当前最大值还大
if (right < n && arr[right] > arr[largest]) {
largest = right;
}
// 如果最大值不是根节点，交换并继续调整堆
if (largest != i) {
int swap = arr[i];
arr[i] = arr[largest];
arr[largest] = swap;
//继续调整堆
heapify(arr, n, largest);
}
}