冒泡排序:
//冒泡排序
public static int[] 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 + 1] < arr[j])
swap(arr, j, j + 1);
}
}
return arr;
}
选择排序:
//选择排序
public static int[] selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[min] > arr[j]) min = j;
}
swap(arr, i, min);
}
return arr;
}
插入排序:
//插入排序
public static int[] insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int j = i - 1;
int temp = arr[i];
while (j >= 0 && temp < arr[j]) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = temp;
}
return arr;
}
希尔排序:
//希尔排序
public static int[] shellSort(int[] arr) {
for (int i = arr.length / 2; i >= 1; i /= 2) {
shell(arr, i);
}
return arr;
}
private static void shell(int[] arr, int k) {
for (int i = k; i < arr.length; i++) {
int temp = arr[i];
int j = i - k;
while (j >= 0 && temp < arr[j]) {
arr[j + k] = arr[j];
j -= k;
}
arr[j + k] = temp;
}
}
归并排序:
//归并排序
public static int[] mergeSort(int[] arr) {
if (arr.length < 2) return arr;
int[] arr1 = Arrays.copyOfRange(arr, 0, arr.length / 2);
int[] arr2 = Arrays.copyOfRange(arr, arr.length / 2, arr.length);
arr1 = mergeSort(arr1);
arr2 = mergeSort(arr2);
return combine(arr1, arr2);
}
private static int[] combine(int[] arr1, int[] arr2) {
int[] arr = new int[arr1.length + arr2.length];
for (int i = 0, j = 0, k = 0; k < arr.length; k++) {
int temp;
if (arr1.length <= i) temp = arr2[j++];
else if (arr2.length <= j) temp = arr1[i++];
else if (arr1[i] < arr2[j]) temp = arr1[i++];
else temp = arr2[j++];
arr[k] = temp;
}
return arr;
}
快速排序:
//快速排序
public static int[] quickSort(int[] arr) {
quickDoSort(arr, 0, arr.length - 1);
return arr;
}
private static void quickDoSort(int[] arr, int left, int right) {
if (left >= right) return;
int partition = getPartition(arr, left, right);
quickDoSort(arr, left, partition - 1);
quickDoSort(arr, partition + 1, right);
}
private static int getPartition(int[] arr, int left, int right) {
int index = left + 1;
int target = arr[left];
for (int i = left + 1; i <= right; i++) {
if (target > arr[i]) {
swap(arr, index, i);
index++;
}
}
swap(arr, index - 1, left);
return index - 1;
}
堆排序:
//堆排序
public static int[] heapSort(int[] arr) {
int length = arr.length;
//构建最大堆
for (int i = (length - 1) / 2; i >= 0; i--) {
adjust(arr, i, length);
}
while (length > 0) {
swap(arr, 0, length - 1);
length--;
adjust(arr, 0, length);
}
return arr;
}
private static void adjust(int[] arr, int i, int length) {
int l = i * 2 + 1;
int r = i * 2 + 2;
int max = i;
if (length > l && arr[l] > arr[max]) max = l;
if (length > r && arr[r] > arr[max]) max = r;
if (max != i) {
swap(arr, max, i);
adjust(arr, max, length);
}
}
计数排序:
//计数排序
public static int[] countingSort(int[] arr) {
int min = arr[0], max = arr[0];
for (int i : arr) {
if (i > max) max = i;
if (i < min) min = i;
}
int[] result = new int[max - min + 1];
for (int i : arr) {
result[i - min]++;
}
int j = 0;
for (int i = 0; i < result.length; i++) {
while (result[i] != 0) {
arr[j++] = i;
result[i]--;
}
}
return arr;
}
桶排序:
//桶排序
public static int[] bucketSort(int[] arr) {
ArrayList<ArrayList<Integer>> buckets = new ArrayList<>();
int min = arr[0], max = arr[0];
for (int i : arr) {
if (i > max) max = i;
if (i < min) min = i;
}
int bucketNum = arr.length / 10;
//初始化arr.length个空桶
for (int i = 0; i < bucketNum; i++) {
buckets.add(new ArrayList<Integer>());
}
for (int val : arr) {
int index = (val - min) / ((max - min + 1) / bucketNum + 1);
buckets.get(index).add(val);
}
for (int i = 0; i < bucketNum; i++) {
Collections.sort(buckets.get(i));
}
int j = 0;
for (int i = 0; i < bucketNum; i++) {
for (int val : buckets.get(i)) {
arr[j++] = val;
}
}
return arr;
}
基数排序:
版本一:
//基数排序(使用数组麻烦)
public static int[] radixSort(int[] arr) {
int max = arr[0];
for (int num : arr) {
if (max < num) max = num;
}
int times = (max + "").length();
int[][] nums = new int[10][arr.length];
//记录每个桶的索引
int[] count = new int[10];
for (int i = 0, n = 1; i < times; i++, n *= 10) {
for (int j = 0; j < arr.length; j++) {
int ys = arr[j] / n % 10;
nums[ys][count[ys]++] = arr[j];
}
int index = 0;
for (int k = 0; k < 10; k++) {
for (int j = 0; j < count[k]; j++) {
arr[index++] = nums[k][j];
}
}
for (int j = 0; j < count.length; j++) {
count[j] = 0;
}
}
return arr;
}
版本二:
//基数排序2(使用list)
public static int[] radixSort2(int[] arr) {
int max = arr[0];
for (int i : arr) {
if (i > max) max = i;
}
int times = (max + "").length();
ArrayList<ArrayList<Integer>> list = new ArrayList<>();
for (int i = 0; i < 10; i++) list.add(new ArrayList<>());
for (int i = 0, n = 1; i < times; i++, n *= 10) {
for (int t = 0; t < arr.length; t++) {
int ys = arr[t] / n % 10;
list.get(ys).add(arr[t]);
}
int index = 0;
for (int j = 0; j < list.size(); j++) {
for (int k = 0; k < list.get(j).size(); k++) {
arr[index++] = list.get(j).get(k);
}
}
for (List l : list) l.clear();
}
return arr;
}