算法比较总结
知识前提
稳定性：
假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
快速排序（挖坑法）
public static void quickSort(int[] arr,int left,int right){
if(left>right){
return;
}
int i = left;int j = right;int key = arr[i];
while(i<j){
while(i<j && arr[j]>=key ){
j--;
}
if(i<j){
arr[i] = arr[j];
i++;
}
while(i<j&& arr[i]>key){
i++;
}
if(i<j){
arr[j] = arr[i];
j--;
}
}
arr[i] = key;
quickSort(arr,left,i-1);
quickSort(arr,i+1,right);
}
思路
一开始取的是0号位置上的元素作为比较条件，因为有外部的key存储，0号位置的元素可以被替代。然后从右边开始遍历，找到第一个比key小的位置j，它应该放到key的左边。挖个新坑j填补旧坑。然后再从左边开始遍历，找到第一个比key大的位置i，再把i位置的元素放到新坑，i称为更新的坑。如此循环结束，最后的坑位在i上，也就是被挖走的key应该放的位置。此时，key的左边都是小于它的数，key的右边都是大于它的数。通过递归，实现排序。
时间空间复杂度
平均时间复杂度：O(nlog(n))
最优时间复杂度：O(nlog(n))。最优情况指的是每次取到的元素正好能够平分整个数组。
最差时间复杂度：O(n^2)。最差情况指的是每次取到的元素正好是数组的最大/最小元素
空间复杂度：（最差）O(log(n))
稳定性
不稳定
如[5,7,7,1,1]，以5为key，最后为[1,1,5,7,7]。斜体1和粗体1的相对位置发生了变化。
希尔排序
public class ShellSort {
public static void main(String[] args) {
int[] a = {1,2,32,1,1,23,4};
shell(a);
System.out.println(a.toString());
}
public static void shell(int a[])
{
int temp= 0;
int incre = a.length;
while(true){
incre = incre/2;
for(int k = 0;k<incre;k++){
for(int i = k+incre;i<a.length;i+=incre){
for(int j = i;j>k;j-= incre){
if(a[j]<a[j-incre]){
temp = a[j];
a[j] = a[j-incre];
a[j-incre]=temp;
}else{
break;
}
}
}
}
if(incre==1){
break;
}
}
}
}
思路
- while循环控制增量
- 第一个for循环找到的是shell分组的每一个开头
- 第二个for循环找到的是从开头算起，每一个相隔incre长度的元素
- 第三个for循环，开始插入排序。
时间空间复杂度(待考证)
平均时间复杂度：O((nlog(n))2) || O(n1.3)
最优时间复杂度：O(n)。所有元素都已经排好序了。
最差时间复杂度：O((nlog(n))2) || O(n2)
空间复杂度：（最差)O(1)
稳定性
不稳定
如：[3,2,2,1]，取incre = 2。
冒泡排序
package sort;
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {1,2,32,1,1,23,4};
bubbleSort(arr);
System.out.println(arr);
}
public static void bubbleSort(int[] arr){
if(arr==null||arr.length==0){
return;
}
for(int i = 1;i<arr.length;i++){
boolean flag = true;
for(int j = 1;j<arr.length-i;j++){
if(arr[j]>arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
flag = false;
}
}
if(flag){
break;
}
}
}
}
思路
- 冒泡冒到最后面，所以第一个for循环用来确定数组的最后面的哪些位置已经不用排序了
- 第二个for循环用来比较排序。
- 增加一个flag，如果在本次循环中，没有发生交换，说明有序。不用再循环。
时间空间复杂度
平均时间复杂度：O(n2)
最优时间复杂度：O(n)。最优情况指的是本身就是有序的数组。因为有flag的存在，一次遍历后就break出来了。
最坏时间复杂度：O(n2)
空间复杂度：O(1)
稳定性
稳定
归并排序
package sort;
public class MergeSort {
public static void main(String[] args) {
int[] a = {1,2,4,2,4,6,8,4,3,5};
int[] temp = new int[a.length];
mergeSort(a,0,a.length-1,temp);
System.out.println(a);
}
public static void mergeSort(int[] arr,int left,int right,int[] temp){
if(left<right){
int middle = (left+right)>>1;
mergeSort(arr,left,middle,temp);
mergeSort(arr,middle+1,right,temp);
MergeArr(arr,left,middle,right,temp);
}
}
private static void MergeArr(int[] arr, int left, int middle, int right, int[] temp) {
int i = left;
int j = middle+1;
int k = left;
while(i<=middle&&j<=right){
if(arr[i]<arr[j]){
temp[k++] = arr[i++];
}else{
temp[k++] = arr[j++];
}
}
while(i<=middle){
temp[k++] = arr[i++];
}
while(j<=right){
temp[k++] = arr[j++];
}
for(int ii = left;ii<=right;ii++){
arr[ii] = temp[ii];
}
}
}
思路
将数组对分，对对分后的两个数组进行排序，两个排完序的数组再进行合并。把对分后的数组再当做一个单独的需要排序的数组，那么上面的一套完全适用于它，就实现了递归。
关于合并：因为两个是已经排好序的数组，所以可以放心地比较两个数组的第一个元素，如果左边数组的第一个元素小于右边数组的第一个元素，那么它一定能保证小于右边数组的所有元素。所以它就能放在临时数组temp的第一个位置。以此类推。但总有一个数组中的元素先放完，但我们不能知道是哪个数组，所以还需要两个while循环把没比较完的那个数组放到temp中。
时间空间复杂度
平均时间复杂度：O(nlogn)
最优时间复杂度：O(nlogn)
最差时间复杂度：O(nlogn)
空间复杂度：O(n)
稳定性
稳定
堆排序
public class HeapSort {
public static void main(String[] args) {
int[] arr1 = {3,5,6,4,1,8};
heapSort(arr1);
}
public static void heapSort(int[] arr){
for(int i = 0;i<arr.length;i++){
for(int j = arr.length-1-i;j>=0;j--){
int left = 2*j+1;
int right = 2*j+2;
int max = j;
if(left<=arr.length-1-i&& arr[left]>arr[max]){
max = left;
}
if(right<=arr.length-1-i && arr[right]>arr[max]){
max = right;
}
if(max != j){
swap(arr,j,max);
}
}
swap(arr,0,arr.length-1-i);
}
}
public static void swap (int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
思路
- 堆排序可以分为最小堆或者最大堆。上面的代码按照最小堆来排序。
- 对于每个二叉数节点i，它的两个子节点分别是 2i+1 和 2i+2
- 要从数组的最后一个节点开始遍历，不然不能把最大/最小值放到数组的头上
- 换完以后要将在头上的最大/最小值放到数组的最后，并将下一次的遍历不包含该值
时间空间复杂度
平均时间复杂度：O(nlogn)
最优时间复杂度：O(nlogn)
最差时间复杂度：O(nlogn)
空间复杂度：O(1)
稳定性
不稳定
选择排序
package sort;
public class SelectSort {
public static void main(String[] args) {
int[] arr = {1,2,3,42,3,4,21,1};
selectSort(arr);
System.out.println(arr);
}
public static void selectSort(int[] arr){
for(int i = 0;i<arr.length;i++){
int min = i;
for(int j = i+1;j<arr.length;j++){
if(arr[min]>arr[j]){
min = j;
}
}
if(min != i){
int temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
}
}
}
思路
从数组中找一个最小的数，然后放到数组的最前面。然后在剩下的数组中找一个最小的数，再放到最前面。如此循环至剩下的数组大小为1。
时间空间复杂度
平均时间复杂度：O(n2)
最优时间复杂度：O(n2)
最差时间复杂度：O(2)
空间复杂度：O(1)
稳定性
不稳定。比如说 [5,3,5,2]，经过一次排序后就完成了排序 [2,3,5,5]，加粗5和正常5的顺序发生了变化。
插入排序
public class InsertSort {
public static void main(String[] args) {
int[] a = {1,2,4,2,9,7,5};
insertSort(a);
System.out.println(a);
}
public static void insertSort(int[] arr){
for(int i = 1;i<arr.length;i++){
int tmp = arr[i];
int j = i;
while(j>0&&arr[j-1]>tmp){
arr[j] = arr[j-1];
j--;
}
if(j!=i){
arr[j] = tmp;
}
}
}
}
思路
从数组的第1号（第二个）元素开始遍历，如果它比前面的元素大，就交换位置。然后再看后面一个元素，先把元素记录下来，如果前面的元素比它大，就往后挪一格，直到找到这个元素该放的位置。
时间空间复杂度
平均时间复杂度：O(n2)
最优时间复杂度：O(n)
最差时间复杂度：O(n2)
空间复杂度：O(1)
稳定性
稳定
2959
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
