冒泡排序
冒泡排序（Bubble Sort）是一种简单的排序算法，它通过重复地遍历要排序的数列，比较相邻元素的大小并交换位置，使得较大的元素逐渐向数列的末尾移动。
以下是Java实现的冒泡排序代码：
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;
}
}
}
}
该算法的时间复杂度为O(n^2)，其中n是待排序数列的长度。
选择排序
选择排序（Selection Sort）是一种简单直观的排序算法，它通过每次从未排序的元素中选出最小（或最大）的元素，将其放到已排序序列的末尾。
以下是Java实现的选择排序代码：
public static void selectionSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
if (minIndex != i) {
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
该算法的时间复杂度为O(n^2)，其中n是待排序数列的长度。
插入排序
插入排序（Insertion Sort）是一种简单直观的排序算法，它通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
以下是Java实现的插入排序代码：
public static void insertionSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
该算法的时间复杂度为O(n^2)，其中n是待排序数列的长度。
快速排序
快速排序（Quick Sort）是一种高效的排序算法，它通过分治的思想将待排序的数列分为两个部分，一部分比另一部分的所有元素都小，然后再对这两部分分别进行排序。
以下是Java实现的快速排序代码：
public static void quickSort(int[] arr, int low, int high) {
if (low < high) {
int pivot = partition(arr, low, high);
quickSort(arr, low, pivot - 1);
quickSort(arr, pivot + 1, high);
}
}
private static int partition(int[] arr, int low, int high) {
int pivot = arr[low];
while (low < high) {
while (low < high && arr[high] >= pivot) {
high--;
}
arr[low] = arr[high];
while (low < high && arr[low] <= pivot) {
low++;
}
arr[high] = arr[low];
}
arr[low] = pivot;
return low;
}
该算法的平均时间复杂度为O(nlogn)，其中n是待排序数列的长度。
归并排序
归并排序（Merge Sort）是一种高效的排序算法，它通过分治的思想将待排序的数列分为两个部分，分别对这两部分进行排序，然后将它们合并成一个有序序列。
以下是Java实现的归并排序代码：
public static void mergeSort(int[] arr, int low, int high) {
if (low < high) {
int mid = (low + high) / 2;
mergeSort(arr, low, mid);
mergeSort(arr, mid + 1, high);
merge(arr, low, mid, high);
}
}
private static void merge(int[] arr, int low, int mid, int high) {
int[] temp = new int[high - low + 1];
int i = low, j = mid + 1, k = 0;
while (i <= mid && j <= high) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
while (i <= mid) {
temp[k++] = arr[i++];
}
while (j <= high) {
temp[k++] = arr[j++];
}
for (int p = 0; p < temp.length; p++) {
arr[low + p] = temp[p];
}
}
该算法的平均时间复杂度为O(nlogn)，其中n是待排序数列的长度。
堆排序
堆排序（Heap Sort）是一种高效的排序算法，它通过构建大顶堆或小顶堆来实现。
以下是Java实现的堆排序代码：
public static void heapSort(int[] arr) {
// 构建大顶堆
for (int i = arr.length / 2 - 1; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
// 交换堆顶元素和末尾元素并重新调整堆
for (int j = arr.length - 1; j > 0; j--) {
swap(arr, 0, j);
adjustHeap(arr, 0, j);
}
}
private static void adjustHeap(int[] arr, int i, int length) {
int temp = arr[i];
for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {
if (k + 1 < length && arr[k] < arr[k + 1]) {
k++;
}
if (arr[k] > temp) {
arr[i] = arr[k];
i = k;
} else {
break;
}
}
arr[i] = temp;
}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
该算法的平均时间复杂度为O(nlogn)，其中n是待排序数列的长度。
希尔排序
希尔排序（Shell Sort）是一种改进的插入排序算法，它通过将待排序数列按照一定的间隔分组，对每组进行插入排序，然后逐渐缩小间隔，直到间隔为1时，整个数列已经基本有序，此时再进行一次普通的插入排序即可。
以下是Java实现的希尔排序代码：
public static void shellSort(int[] arr) {
int gap = arr.length / 2;
while (gap > 0) {
for (int i = gap; i < arr.length; i++) {
int j = i;
int temp = arr[j];
while (j - gap >= 0 && temp < arr[j - gap]) {
arr[j] = arr[j - gap];
j -= gap;
}
arr[j] = temp;
}
gap /= 2;
}
}
该算法的平均时间复杂度为O(n^1.3)，其中n是待排序数列的长度。
计数排序
计数排序（Counting Sort）是一种非比较的排序算法，它通过统计每个元素出现的次数，然后根据元素出现的次数来对元素进行排序。
以下是Java实现的计数排序代码：
public static void countingSort(int[] arr) {
int max = Integer.MIN_VALUE;
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
int[] count = new int[max + 1];
for (int i = 0; i < arr.length; i++) {
count[arr[i]]++;
}
int index = 0;
for (int i = 0; i < count.length; i++) {
while (count[i] > 0) {
arr[index++] = i;
count[i]--;
}
}
}
该算法的时间复杂度为O(n+k)，其中n是待排序数列的长度，k是待排序数列中的最大值。
桶排序
桶排序（Bucket Sort）是一种非比较的排序算法，它通过将待排序数列分到有限数量的有序桶中，然后对每个桶再进行排序，最后将各个桶中的数据依次取出即可得到有序序列。
以下是Java实现的桶排序代码：
public static void bucketSort(int[] arr) {
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
if (arr[i] < min) {
min = arr[i];
}
}
int bucketNum = (max - min) / arr.length + 1;
ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
for (int i = 0; i < bucketNum; i++) {
bucketArr.add(new ArrayList<>());
}
for (int i = 0; i < arr.length; i++) {
int num = (arr[i] - min) / arr.length;
bucketArr.get(num).add(arr[i]);
}
int index = 0;
for (int i = 0; i < bucketArr.size(); i++) {
Collections.sort(bucketArr.get(i));
for (int j = 0; j < bucketArr.get(i).size(); j++) {
arr[index++] = bucketArr.get(i).get(j);
}
}
}
该算法的时间复杂度为O(n+k)，其中n是待排序数列的长度，k是待排序数列中的最大值。
基数排序
基数排序（Radix Sort）是一种非比较的排序算法，它通过将待排序数列按照位数进行分组，然后对每个位数进行计数排序，最后将各个位数的数据依次取出即可得到有序序列。
以下是Java实现的基数排序代码：
public static void radixSort(int[] arr) {
int max = Integer.MIN_VALUE;
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
int maxDigit = 0;
while (max != 0) {
max /= 10;
maxDigit++;
}
int mod = 10, div = 1;
ArrayList<ArrayList<Integer>> bucketList = new ArrayList<>();
for (int i = 0; i < 10; i++) {
bucketList.add(new ArrayList<>());
}
for (int i = 0; i < maxDigit; i++, mod *= 10, div *= 10) {
for (int j = 0; j < arr.length; j++) {
int num = (arr[j] % mod) / div;
bucketList.get(num).add(arr[j]);
}
int index = 0;
for (int j = 0; j < bucketList.size(); j++) {
for (int k = 0; k < bucketList.get(j).size(); k++) {
arr[index++] = bucketList.get(j).get(k);
}
bucketList.get(j).clear();
}
}
}
该算法的时间复杂度为O(n*k)，其中n是待排序数列的长度，k是待排序数列中的最大值的位数。