程序员基本功系列2——排序算法
作者：互联网
1、衡量排序算法的标准
其实几乎所有算法都可以从几个方便进行衡量：执行效率、内存开销、稳定性。
排序算法也一样，主要从：
• 时间复杂度，包括：最好情况、最坏情况、平均时间复杂度、还有比较和交换的次数
• 空间复杂度，如：原地排序
• 排序算法的稳定性，即相同数值的元素，排序后的前后顺序不变则称为稳定排序
来汇总一下常用排序算法：
| 算法分类 | 时间复杂度 | 空间复杂度 | 是否基于比较 | 是否稳定排序 |
| 冒泡、插入、选择 | O(n2) | O(1) | 是 | 冒泡和插入是稳定排序，选择是非稳定排序 |
| 快排、归并 | O(nlogn) | 是 | ||
| 桶排序、计数、基数 | O(n) | 否 |
2、冒泡、插入和选择
2.1、冒泡排序
举个简单的例子：对数组[4,5,6,3,2,1]进行排序。看下冒泡过程分解：
冒泡排序包含两个关键操作：比较和交换，根据上面的分析，我们写出具体的代码：
// 冒泡排序，a表示数组，n表示数组大小
public void bubbleSort(int[] a, int n) {
if (n <= 1) return;
for (int i = 0; i < n; ++i) {
// 提前退出冒泡循环的标志位
boolean flag = false;
for (int j = 0; j < n - i - 1; ++j) {
if (a[j] > a[j+1]) { // 交换
int tmp = a[j];
a[j] = a[j+1];
a[j+1] = tmp;
flag = true; // 表示有数据交换
}
}
if (!flag) break; // 没有数据交换，提前退出
}
}
冒泡排序比较简单，注意这里我们设置了一个退出标志位，当数组已经当前位置后续元素已经有序的情况下，减少不必要的循环逻辑。
冒泡排序的最好情况下时间复杂度，即数组有序时（1，2，3，4，5，6），是O(n)；最坏情况时间复杂度，即数组逆序（6，5，4，3，2，1），是O(n2)；平均时间复杂度是 O(n2)。
冒泡排序是原地排序，空间复杂度 O(1)。
冒泡排序是稳定是排序，因为 a[j] == a[j+1] 时没有进行交换，所以前后顺序不会变。
2.2、插入排序
插入排序思想：将数组中的数据分为两个区间，已排序区间和未排序区间。初始已排序区间只有一个元素，就是数组的第一个元素。然后取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，并保证已排序区间数据一直有序。重复这个过程，直到未排序区间中元素为空，算法结束。
对数组[4,5,6,3,2,1]进行排序，看下插入过程分解：
根据以上分析，我们写出具体代码：
// 插入排序，a表示数组，n表示数组大小
public void insertionSort(int[] a, int n) {
if (n <= 1) return;
for (int i = 1; i < n; ++i) {
int value = a[i];// 查找插入的位置
for (int j=i-1; j >= 0; --j) {
if (a[j] > value) {
a[j+1] = a[j]; // 数据移动
} else {
break;
}
}
a[j+1] = value; // 插入数据，注意这里是a[j+1]，因为循环结束找到要插入位置后，后面的--j还会执行。
}
}
插入排序的最好情况下时间复杂度，即数组有序时（1，2，3，4，5，6），是O(n)；最坏情况时间复杂度，即数组逆序（6，5，4，3，2，1），是O(n2)；平均时间复杂度是 O(n2)。
插入排序是原地排序，空间复杂度 O(1)。
插入排序是稳定是排序，因为 a[j] == value 时没有将 a[j] 移动，所以前后顺序不会变。
2.3、选择排序
选择排序算法的实现思路有点类似插入排序，也分已排序区间和未排序区间。但是选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾。
根据以上分析，我们写出代码：
// 选择排序，a表示数组，n表示数组大小
public void selectSort(int[] a, int n) {
if (n <= 1) return;
for (int i = 0; i < n; ++i) {
int min_idx = i;
// 找到最小元素的位置
for (int j=i+1; j < n; ++j) {
if (a[j] < a[min_idx]) {
min_idx = j;
}
}
//移动未排序区最小元素到排序区
if(min_idx != i){
int tmp = a[i];
a[i] = a[min_idx];
a[min_idx] = tmp;
}
}
}
选择排序的最好情况下时间复杂度，即数组有序时（1，2，3，4，5，6），是O(n)；最坏情况时间复杂度，即数组逆序（6，5，4，3，2，1），是O(n2)；平均时间复杂度是 O(n2)。
选择排序是原地排序，空间复杂度 O(1)。
选择排序是不稳定是排序，因为每次都要找到未排序区最小元素和前面的元素交换位置，这样破坏了稳定性。例如：[5,8,5,2,4]，当第一个5和2交换位置时稳定性就被破坏了。
3、快速和归并
快速排序和归并排序都用到了分治思想，适合大规模数据排序，比上面三种更常用。
3.1、归并排序
归并排序的核心思想是：把数组从中间分成前后两部分，然后对前后两部分分别排序，再将排好序的两部分合并在一起，这样整个数组就都有序了。
分治思想都会用到递归，我们来看下递推公式：
merge_sort(p..r) = merge_sort(p...m) + merge_sort(m+1...r)，终止条件：当 p >= r 时不再继续分解。
到这里，分解的过程就结束了，但是分解后还有一个合并的过程，就是将已经有序的 A[p...m] 和 A[m+1...r] 合并成一个有序数组，然后放入 A[p...r]。
合并的逻辑：申请一个临时数组 tmp，大小与 A[p...r] 相同。用两个游标 i 和 j，分别指向 A[p...m]和 A[m+1...r]的第一个元素。比较这两个元素 A[i] 和 A[j]，如果 A[i]<=A[j]，就把 A[i] 放入到临时数组 tmp，并且 i 后移一位，否则将 A[j]放入到数组 tmp，j 后移一位。继续上述比较过程，直到其中一个子数组中的所有数据都放入临时数组中，再把另一个数组中的数据依次加入到临时数组的末尾，这个时候，临时数组中存储的就是两个子数组合并之后的结果了。最后再把临时数组 tmp 中的数据拷贝到原数组 A[p...r]中。
根据以上分析，我们写出整个分解与合并的代码：
public class MergeSort {
public static void main(String[] args) {
int[] arr = {4,5,6,3,2,1};
int len = arr.length;
sort(arr,0,len-1);
for (int item : arr){
System.out.print(item);
}
}
/**
* 分解
*/
private static void sort(int[] arr,int left,int right){
//终止条件
if (left >= right)return;
int mid = (left+right) / 2;
sort(arr,left,mid);
sort(arr,mid+1,right);
//如果两个数组已经有序，就不用再合并了
if (arr[mid] <= arr[mid+1]){
return;
}
//合并两段区间
merge(arr,left,mid,right);
}
/**
* 合并
*/
private static void merge(int[] arr,int left,int mid,int right){
//创建临时数组
int[] tmp = new int[right-left+1];
int i=left,j=mid+1;
for (int k=0;k<tmp.length;k++){
//如果左侧
if (i == mid+1){
tmp[k] = arr[j++];
}else if (j == right+1){
tmp[k] = arr[i++];
}
//这一步如果去掉等号，就破坏调了稳定性
else if (arr[i] <= arr[j]){
tmp[k] = arr[i++];
}else {
tmp[k] = arr[j++];
}
}
//采用Java自带的数组拷贝，也可以写个循环
System.arraycopy(tmp, 0,arr, left, tmp.length);
}
}
public class MergeSort {
public static void main(String[] args) {
int[] arr = {4,5,6,3,2,1};
int len = arr.length;
sort(arr,0,len-1);
for (int item : arr){
System.out.print(item);
}
}
/**
* 分解
*/
private static void sort(int[] arr,int left,int right){
//终止条件
if (left >= right)return;
int mid = (left+right) / 2;
sort(arr,left,mid);
sort(arr,mid+1,right);
//如果两个数组已经有序，就不用再合并了
if (arr[mid] <= arr[mid+1]){
return;
}
//合并两段区间
merge(arr,left,mid,right);
}
/**
* 合并
*/
private static void merge(int[] arr,int left,int mid,int right){
//创建临时数组
int[] tmp = new int[right-left+1];
int i=left,j=mid+1;
for (int k=0;k<tmp.length;k++){
//如果左侧
if (i == mid+1){
tmp[k] = arr[j++];
}else if (j == right+1){
tmp[k] = arr[i++];
}
//这一步如果去掉等号，就破坏调了稳定性
else if (arr[i] <= arr[j]){
tmp[k] = arr[i++];
}else {
tmp[k] = arr[j++];
}
}
//采用Java自带的数组拷贝，也可以写个循环
System.arraycopy(tmp, 0,arr, left, tmp.length);
}
}
标签：sort,arr,int,复杂度,程序员,数组,基本功,排序 来源： https://www.cnblogs.com/jing-yi/p/15853933.html