各种排序算法时间复杂度和空间复杂度
快速排序
思想
放码过来
public class QuickSort {
private static int Partition(int[] arr, int start, int end) {
//arr[start]为挖的第一个坑
int key = arr[start];
while (start < end) {
while (arr[end] >= key && end > start)
end--;
arr[start] = arr[end];
while (arr[start] <= key && end > start)
start++;
arr[end] = arr[start];
}
arr[start] = key;
return start;
}
public static void sort(int[] arr, int start, int end) {
if (start < end) {
int index = Partition(arr, start, end);
sort(arr, start, index - 1);
sort(arr, index + 1, end);
}
}
}
归并排序
排序思想
归并排序（MERGE-SORT） 是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。
分而治之
放码过来
public class MergeSort {
public static void sort(int[] array,int low,int high) {
if ((high-low) == 0||((high-low) == 1)) {
return;
}
int mid = (low + high) / 2;
if (low < high) {
// 左边
sort(array, low, mid);
// 右边
sort(array, mid + 1, high);
// 左右归并
mergeSort(array, low, mid, high);
}
}
private static void mergeSort(int[] array, int low, int mid, int high) {
int[] temp = new int[high - low + 1];
int i = low;
int j = mid + 1;
int k = 0;
//把数据移动到temp数据之中
while (i <= mid && j <= high) {
if (array[i] < array[j]) {
temp[k++] = array[i++];
} else {
temp[k++] = array[j++];
}
}
while (i <= mid) {
temp[k++] = array[i++];
}
while (j <= high) {
temp[k++] = array[j++];
}
//copy
for (k = 0; k < temp.length; k++) {
array[low + k] = temp[k];
}
}
}
选择排序
排序思想
选择排序(Selection sort) 是一种简单直观的排序算法。 它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。 以此类推，直到全部待排序的数据元素的个数为零。 选择排序是不稳定的排序方法。
放码过来
public class SelectSort {
public static int[] sort(int[] array) {
if (array.length == 0)
return array;
for (int i = 0; i < array.length; i++) {
int minIndex = i;
for (int j = i + 1; j < array.length; j++) {
if(array[j]<array[minIndex]){
minIndex = j;
}
}
//swap 下表 i 和 min
int tmp = array[i];
array[i] = array[minIndex];
array[minIndex] = tmp;
}
return array;
}
}
