各数组排序的比较
| 排序名称 | 时间复杂度 | 稳定排序 | 原地排序 | 适用情景 |
|---|---|---|---|---|
| 冒泡 | O ( N 2 ) O(N^2) O(N2) | 稳定 | 原地 | 数量小或顺序已经基本排好 |
| 插入 | O ( N 2 ) O(N^2) O(N2) | 稳定 | 原地 | / |
| 选择 | O ( N 2 ) O(N^2) O(N2) | 不稳定 | 原地 | / |
| 希尔 | < O ( N 2 ) <O(N^2) <O(N2) | 不稳定 | 原地 | / |
| 快速 | O ( N l g N ) O(NlgN) O(NlgN) | 不稳定 | 原地 | 大量随机数 |
| 合并 | O ( N l g N ) O(NlgN) O(NlgN) | 稳定 | 不原地 | / |
| 桶 | O ( N ) O(N) O(N) | 稳定 | 不原地 | 正整数排序 |
1. 冒泡排序
Bubble Sort：相邻的两个数小的放前面大的放后面，以此类推，与选择排序形似，向前比较，图解见：Java Bubble Sort 冒泡排序图解；
- 时间复杂度： O ( n 2 ) O(n^2) O(n2)；
- 稳定：同值的元素位置不会改变；
- 原地排序；
public class Test {
//冒泡排序
public static void bubbleSort(int[] array) {
int temp = 0;
//外层循环,控制选中的元素，-1可以控制每轮比较的次数
for (int i = 0; i < array.length - 1; i++) {
//内层循环,控制进行比较的元素, -1-i是为了调高比较效率
for (int j = 0; j < array.length - 1 - i; j++) {
//比较 array[i] array[j]
if (array[j] > array[j + 1]) {
//交换
temp = array[j + 1];
array[j + 1] = array[j];
array[j] = temp;
}
}
}
//打印
System.out.println(Arrays.toString(array));
}
public static void main(String[] args) {
int array[] = {1, 66, 88, 22, 3};
bubbleSort(array);
}
}
/*
输出
[1, 3, 22, 66, 88]
*/
2. 插入排序
Insertion Sort：每步将一个待排序的记录，按其值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止；
- 时间复杂度： O ( n 2 ) O(n^2) O(n2)；
- 稳定：同值的元素位置不会改变；
- 原地排序；
import java.util.Arrays;
public class Test {
//插入排序
private static void insertionSort(int[] array) {
if (array == null || array.length < 2) {
System.out.println(Arrays.toString(array));
}
for (int i = 1; i < array.length; i++) {
int temp = array[i];
int indx = i;
for (int j = i; j > 0; j--) {
if (temp < array[j - 1]) {
array[j] = array[j - 1];
indx = j - 1;
} else {
break;
}
array[indx] = temp;
}
}
System.out.println(Arrays.toString(array));
}
public static void main(String[] args) {
int array[] = {1, 66, 88, 22, 3};
insertionSort(array);
}
}
/*
输出
[1, 3, 22, 66, 88]
*/
3. 选择排序
Selection Sort：选出最大或最小的放在起始位置，以此类推，与冒泡排序形似，向后比较，图解见：Java 选择排序图解；
- 时间复杂度： O ( n 2 ) O(n^2) O(n2)；
- 不稳定：同值的元素位置会改变；
- 原地排序；
public class Test {
//选择排序
static void selectSort(int[] array) {
//外层循环,控制选中的元素，-1可以控制每轮比较的次数
for (int i = 0; i < array.length - 1; i++) {
//内层循环,控制进行比较的元素, 从i+1开始是为了调高比较效率
for (int j = i + 1; j < array.length; j++) {
//比较 array[i] array[j]
if (array[i] > array[j]) {
//交换
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
//打印
System.out.println(Arrays.toString(array));
}
public static void main(String[] args) {
int array[] = {1, 66, 88, 22, 3};
selectSort(array);
}
}
/*
输出
[1, 3, 22, 66, 88]
*/
4. 希尔排序
Shell’s Sort（也称 Diminishing Increment Sort 缩小增量排序）：将整个有序序列分割成若干小的子序列分别进行插入排序；
- 排序过程：先取一个正整数 d1，把所有序号相隔 d1 的数组元素放一组，组内进行直接插入排序；然后取 d2 < d1，重复上述分组和排序操作；直至di=1，即所有记录放进一个组中排序为止；
- 时间复杂度： < O ( n 2 ) <O(n^2) <O(n2)；
- 不稳定：同值的元素位置会改变；
- 原地排序；
public class Test {
static void ShellPass(int[] array, int d) {
//希尔排序
int gap = array.length;
while (true) {
gap /= 2;//增量每次减半
for (int i = 0; i < gap; i++) {
for (int j = i + gap; j < array.length; j += gap) {//这个循环里其实就是一个插入排序
int temp = array[j];
int k = j - gap;
while (k >= 0 && array[k] > temp) {
array[k + gap] = array[k];
k -= gap;
}
array[k + gap] = temp;
}
}
if (gap == 1)
break;
}
}
public static void main(String[] args) {
int array[] = {1, 66, 88, 22, 3};
ShellPass(array, 1);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
}
5. 快速排序
Quick Sort：它选择一个数做为 pivot（基准），将数组分为两部分，比基准数小的放在左边，比基准数大的放在的右边，然后分别对左边一部分和右边一部分重复上述操作；
- 时间复杂度： O ( n l o g n ) O(nlogn) O(nlogn)；
- 不稳定：同值的元素位置会改变；
- 原地排序；
public class Test {
/*
思路：
p <- Get a number from array
Loop if left < right
Put elements <= p to the left side
Put elements >= p to the right side
Recursive quickSort the left parts and right parts
*/
public static void quickSort(int[] arr, int head, int tail) {
int start = head;
int end = tail;
int pivot = arr[head];
while (start < end) {
//从后往前开始比较
while (end > start && arr[end] >= pivot)//如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
end--;
if (arr[end] <= pivot) {
int temp = arr[end];
arr[end] = arr[start];
arr[start] = temp;
}
//从前往后比较
while (end > start && arr[start] <= pivot)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置，然后又从后往前比较
start++;
if (arr[start] >= pivot) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
//此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
}
//递归
if (start > head)
quickSort(arr, head, start - 1);
if (start < tail)
quickSort(arr, end + 1, tail);
}
public static void main(String[] args) {
int array[] = {1, 66, 88, 22, 3};
quickSort(array, 0, array.length - 1);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
}
6. 合并排序
Merge Sort（也称归并排序）：将已有序的子序列合并，得到完全有序的序列，即先使每个子序列有序，再使子序列段间有序；
- 若将两个有序表合并成一个有序表，称为2-路归并；
- 时间复杂度： O ( n l o g n ) O(nlogn) O(nlogn)；
- 稳定：同值的元素位置不会改变；
- 不原地排序；
import java.util.Arrays;
public class Test {
static void mergeSort(int[] array) {
int length = array.length;
int middle = length / 2;
if (length > 1) {
int[] left = Arrays.copyOfRange(array, 0, middle);//拷贝数组array的左半部分
int[] right = Arrays.copyOfRange(array, middle, length);//拷贝数组array的右半部分
mergeSort(left);//递归array的左半部分
mergeSort(right);//递归array的右半部分
merge(array, left, right);//数组左半部分、右半部分合并到Array
}
}
static void merge(int[] result, int[] left, int[] right) {
int i = 0, l = 0, r = 0;
while (l < left.length && r < right.length) {
if (left[l] < right[r]) {
result[i] = left[l];
i++;
l++;
} else {
result[i] = right[r];
i++;
r++;
}
}
while (r < right.length) {//如果右边剩下合并右边的
result[i] = right[r];
r++;
i++;
}
while (l < left.length) {
result[i] = left[l];
l++;
i++;
}
}
public static void main(String[] args) {
int array[] = {1, 66, 88, 22, 3};
mergeSort(array);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
}
7. 桶排序
Bucket sort（也称箱排序）：将数组分到有限数量的桶子里，每个桶子再个别排序；
- 时间复杂度： O ( N ) O(N) O(N)
- 稳定：同值的元素位置不会改变；
- 不原地排序；
public class Test {
public static void basket(int data[]) {//data为待排序数组
int n = data.length;
int bask[][] = new int[10][n];
int index[] = new int[10];
int max = Integer.MIN_VALUE;
for (int i = 0; i < n; i++) {
max = max > (Integer.toString(data[i]).length()) ? max : (Integer.toString(data[i]).length());
}
String str;
for (int i = max - 1; i >= 0; i--) {
for (int j = 0; j < n; j++) {
str = "";
if (Integer.toString(data[j]).length() < max) {
for (int k = 0; k < max - Integer.toString(data[j]).length(); k++) {
str += "0";
}
}
str += Integer.toString(data[j]);
bask[str.charAt(i) - '0'][index[str.charAt(i) - '0']++] = data[j];
}
int pos = 0;
for (int j = 0; j < 10; j++) {
for (int k = 0; k < index[j]; k++) {
data[pos++] = bask[j][k];
}
}
for (int x = 0; x < 10; x++) {
index[x] = 0;
}
}
}
public static void main(String[] args) {
int array[] = {1, 66, 88, 22, 3};
basket(array);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
}
1120
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
