1.冒泡排序
/**
* 冒泡排序
* 时间复杂度：O(n*n),空间复杂度O(1),稳定排序
*/
public static void bubbleSort(int[] arr) {
int temp;
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]) { // 相邻元素两两对比
swap(arr, j, j+1);
}
}
}
}
2.选择排序
/**
* 选择排序
* 时间复杂度O(n*n),空间复杂度O(1),不稳定排序
*/
public static void selectSort(int[] arr) {
int minIndex;
for(int i = 0; i < arr.length; i++) {
minIndex = i;
for(int j = minIndex + 1; j < arr.length; j++) {
if(arr[minIndex] > arr[j]) {// 寻找最小的数
minIndex = j;
}
}
swap(arr, i, minIndex);
}
}
3.插入排序
/**
* 插入排序
* 时间复杂度O(n*n),空间复杂度O(1),稳定排序
*/
public static void insertSort(int[] arr) {
int len = arr.length;
int preIndex, current;
for(int i = 1; i < len; i++) {
preIndex = i - 1;
current = arr[i];
while(preIndex >= 0 && arr[preIndex] > current) {
arr[preIndex + 1] = arr[preIndex];
preIndex --;
}
arr[preIndex + 1] = current;
}
}
4.归并排序
/**
* 归并排序
* 时间复杂度O(n*lgn),空间复杂度O(1),稳定排序
*/
public static int[] mergeSort(int[] arr) {
if(arr.length == 1) {
return arr;
}
int mid = (int)Math.floor(arr.length / 2);
int[] left = Arrays.copyOfRange(arr, 0, mid);
int[] right = Arrays.copyOfRange(arr, mid, arr.length);
return merge(mergeSort(left), mergeSort(right));
}
private static int[] merge(int[] left, int[] right) {
int[] res = new int[left.length + right.length];
int num = 0;
int i = 0, j = 0;
while (i < left.length && j < right.length) {
if(left[i] < right[j]) {
res[num++] = left[i];
i++;
} else {
res[num++] = right[j];
j++;
}
}
while (i < left.length) {
res[num++] = left[i];
i++;
}
while (j < right.length) {
res[num++] = right[j];
j++;
}
return res;
}
5.快速排序
/**
* 快速排序
* 时间复杂度O(n*lgn),空间复杂度O(1),不稳定排序
*/
public static void quickSort(int[] arr, int left, int right) {
if(left < right) {
int partIndex = partition(arr, left, right);
quickSort(arr, left, partIndex);
quickSort(arr, partIndex + 1, right);
}
}
private static int partition(int[] arr, int left, int right) {
int pivot = left;
int index = pivot + 1;
for(int i = index; i <= right; i++) {
if(arr[i] < arr[pivot]) {
swap(arr, i, index);
index++;
}
}
swap(arr, pivot, index - 1);
return index - 1;
}
6.堆排序
/**
* 堆排序
* 时间复杂度O(n*lgn),空间复杂度O(1),不稳定排序
*/
public static void heapSort(int[] arr) {
buildHeap(arr);
for(int i = arr.length - 1; i > 0; i--) {
swap(arr, 0, i);
adjustHeap(arr, i, 0);
}
}
private static void buildHeap(int[] arr) {
for(int i = (int)Math.floor(arr.length / 2); i >= 0; i--) {
adjustHeap(arr, arr.length, i);
}
}
private static void adjustHeap(int[] arr, int len, int i) {
int left = 2 * i + 1, right = 2 * i + 2, max = i;
if(left < len && arr[left] > arr[max]) {
max = left;
}
if(right < len && arr[right] > arr[max]) {
max = right;
}
if(max != i) {
swap(arr, max, i);
adjustHeap(arr, len, max);
}
}
7.计数排序
/* *
* 计数排序
* 时间复杂度O(n+k),空间复杂度O(n+k),稳定排序
*/
public static void countSort(int[] arr, int maxValue) {
int[] bucket = new int[maxValue + 1];
Arrays.fill(bucket, 0);
for(int i = 0; i < arr.length; i++) {
bucket[arr[i]]++;
}
int num = 0;
for(int i = 0; i <= maxValue; i++) {
while(bucket[i] > 0) {
arr[num++] = i;
bucket[i]--;
}
}
}
