一、冒泡排序(Bubble Sort)
只会操作相邻的两个数据,每次比较相邻的数据大小,不符合要求,就进行一次数据移动,一次冒泡会至少让一个元素处于正确的位置,冒泡n次后,数据符合要求。冒泡排序只会移动相邻元素的变动。
是否是稳定排序:是
是否是原地排序:是
最好情况时间复杂度:O(n)
最坏情况时间复杂度:O(n^2)
平均情况时间复杂度:O(n^2)
代码实现:
public static void bubbleSort(int[] a) {
for (int i = 0; i < a.length - 1; i++) {
// 提前标识位
boolean flag = false;
for (int j = 0; j < a.length - i -1; j++) {
if (a[j] > a[j + 1]) {
int temp = a[j];
a[j] = a[j + 1];
a[j+1] = temp;
flag = true;
}
}
if (!flag) {
// 没有数据交换提前退出
break;
}
}
}
二、插入排序(Insertion Sort)
就是将数据一个个插入到指定位置的排序算法;对于一个静态的数组,可以分为已排序区间和未排序区间,初始的排序区间为1,其排序流程就是将未排序区间中的元素,插入到已排序区间中。
是否是稳定排序:是
是否是原地排序:是
最好情况时间复杂度:O(n)
最坏情况时间复杂度:O(n^2)
平均情况时间复杂度:O(n^2)
代码实现:
public static void insertionSort(int[] a) {
for (int i = 1; i < a.length; i++) {
int value = a[i];
int j = i - 1;
for (; j >= 0; --j) {
if (a[j] > value) {
a[j+1] = a[j];
} else {
break;
}
}
a[j + 1] = value;
}
}
三、选择排序(Selection Sort)
也是分已排序空间和未排序空间,但是选择排序每次会从未排序区间中找到最小的元素,将其放到已排序区间的末尾。
是否是稳定排序:是
是否是原地排序:否
最好情况时间复杂度:O(n)
最坏情况时间复杂度:O(n^2)
平均情况时间复杂度:O(n^2)
代码实现:
public static void selectionSort(int[] a) {
for (int i = 0; i < a.length - 1; i++) {
int minIndex = i;
for (int j = i; j < a.length - 1; j++) {
if (a[j] < a[minIndex]) {
minIndex = j;
}
}
// 进行数据的交换
int temp = a[i];
a[i] = a[minIndex];
a[minIndex] = temp;
}
}
四、归并排序
就是将需要排序的数组,先从中间分成两部分,对着两部分进行排序后,在将排序后的两个数组进行合并,最后这个新的数组就是有序的了。归并排序采用的思想就是分治,将大问题拆解为小问题,最后再将小问题就行合并;也就是先分,后合。
是否是稳定排序:是
是否是原地排序:否,空间复杂度为O(n)
最好情况时间复杂度:O(nlogn)
最坏情况时间复杂度:O(nlogn)
平均情况时间复杂度:O(nlogn)
代码实现:
public static void mergeSort(int[] a, int p, int r) {
// 递归终止条件
if (p >= r) {
return;
}
// 取p和r的中间值
int q = p + (r - p)/2;
mergeSort(a, p, q);
mergeSort(a, q + 1, r);
merge(a, p, q, r);
}
private static void merge(int[] a, int p, int q, int r) {
int i = p;
int j = q+1;
int k = 0; // 初始化变量i, j, k
int[] tmp = new int[r-p+1]; // 申请一个大小跟a[p...r]一样的临时数组
while (i<=q && j<=r) {
if (a[i] <= a[j]) {
tmp[k++] = a[i++]; // i++等于i:=i+1
} else {
tmp[k++] = a[j++];
}
}
// 判断哪个子数组中有剩余的数据
int start = i;
int end = q;
if (j <= r) {
start = j;
end = r;
}
// 将剩余的数据拷贝到临时数组tmp
while (start <= end) {
tmp[k++] = a[start++];
}
// 将tmp中的数组拷贝回a[p...r]
for (i = 0; i <= r-p; ++i) {
a[p+i] = tmp[i];
}
}
五、快速排序
从需要排序的数组下标q和r之间,选择一个数据作为pivot(分区点)。然后遍历q和r的数据,将小于pivot的数据放在pivot的左边,大于pivot的数据放在右边,这样数组就被分成三个部分小于pivot的数据,pivot数据,大于pivot的数据,重复上述步骤直到区间到1,完成排序。
是否是稳定排序:否
是否是原地排序:是
最好情况时间复杂度:O(nlogn)
最坏情况时间复杂度:O(n^2)
平均情况时间复杂度:O(nlogn)
代码实现:
public static void quickSort(int[] a, int p, int r) {
if (p >= r) {
return;
}
int q = partition(a, p, r); // 获取分区点
quickSort(a, p, q-1);
quickSort(a, q+1, r);
}
private static int partition(int[] a, int p, int r) {
int pivot = a[r];
int i = p;
for(int j = p; j < r; ++j) {
if (a[j] < pivot) {
if (i == j) {
++i;
} else {
int tmp = a[i];
a[i++] = a[j];
a[j] = tmp;
}
}
}
int tmp = a[i];
a[i] = a[r];
a[r] = tmp;
System.out.println("i=" + i);
return i;
}