做相亲网站的红娘累吗网址注册

冒泡排序

冒泡排序（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是待排序数列中的最大值的位数。