排序算法总结

目录

选择排序

插入排序

希尔排序

归并排序

快速排序

---

int[] d=new int[]{5,7,6,3,1,2,8,9,4};用排序算法心中模拟排序？

---

选择排序

首先，找到数组中最小的元素，将其与数组的第一个元素交换位置。然后再在剩余的元素中找最小的元素，与数组的第二个元素交换位置。如此往复，直到整个数组排序。

public class Selection {
    public static void sort(int[] nums){
        for(int i=0;i<nums.length;i++){
            int min=i;
            for(int j=i;j<nums.length;j++){//在剩余的元素中寻找最小元素
                if(nums[j]<nums[min]){
                    min=j;
                }
            }
            int temp=nums[i];//与最前面的交换位置
            nums[i]=nums[min];
            nums[min]=temp;
        }
    }
}

代码中需要大约N²/2次比较和N次交换，无额外空间

时间复杂度O（N²），空间复杂度O（1）

• 运行时间和输入无关
• 数据移动是最少的

---

插入排序

 将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表

public class Insertion {
    public static void sort(int[] nums) {
        for(int i=1;i<nums.length;i++){
            for(int j=i;j>0;j--){
                if(nums[j]<nums[j-1]){
                    int temp=nums[j];
                    nums[j]=nums[j-1];
                    nums[j-1]=temp;
                }
            }
        }
    }
}

最好情况：数组顺序：需要N-1次比较，0次交换

最坏情况：数组逆序：需要N²/2次比较，N²/2次交换

平均情况：需要N²/4次比较，N²/4次交换

时间复杂度O（N²），空间复杂度O（1）

• 插入排序对部分有序的数组十分高效，也很适合小规模数组
• 对于大规模乱序数组插入排序很慢，因为它只会交换相邻的元素，因此元素只能一点一点地从数组的一端移动到另一端，可以用希尔排序改进

---

希尔排序

为了加快速度简单的改进了插入排序。交换不相邻的元素以对数组的局部进行排序，并最终用插入排序将局部有序的数组排序

public class Shell {
    public static void sort(int[] nums) {
        int N=nums.length;
        int h=1;
        while(h<N/3){
            h=3*h+1;
        }
        while (h>=1){
            for(int i=h;i<N;i++){
                for(int j=i;j>=h;j-=h){
                    if(nums[j]<nums[j-h]) {
                        int temp = nums[j];
                        nums[j]=nums[j-h];
                        nums[j-h]=temp;
                    }
                }
            }
            h=h/3;
        }
    }
}

• 研究希尔排序需要的数学论证复杂，希尔排序比插入排序和选择排序快得多。

有经验的程序员有时会选择希尔排序，因为对于中等大小的数组他的运行时间是可以接受的，代码量很小，不需要使用额外内存空间。而下面几个更加高效的算法，除了对于很大的N，它们可能只会比希尔排序快两倍（可能还不到），而且更复杂。

---

归并排序

要将一个数组排序，可以先（递归地）将它分成两半分别排序，然后将结果归并起来

自顶向下 （sort函数递归的分成两半，merge函数将结果归并起来排序）

public class Merge {
    private static int[] aux;//归并所需的辅助数组

    public static void sort(int[] a){
        aux=new int[a.length];//一次性分配空间
        sort(a,0,a.length-1);
    }

    private static void sort(int[] a,int lo,int hi){
        if(hi<=lo) return;
        int mid=lo+(hi-lo)/2;
        sort(a,lo,mid);
        sort(a,mid+1,hi);
        merge(a,lo,mid,hi);//将已经排好序的两部分传入合并函数合并
    }

    private static void merge(int[] a,int lo,int mid,int hi){
        int i=lo,j=mid+1;
        for(int k=lo;k<=hi;k++){
            aux[k]=a[k];//将这一部分的a传入辅助数组aux
        }
        for(int k=lo;k<=hi;k++){//合并两个已经排好序的部分
            if(i>mid) a[k]=aux[j++];//若左边部分已经全部加入数组，则直接加右边部分
            else if(j>hi) a[k]=aux[i++];//若右边部分已经全部加入数组，则直接加左边部分
            else if(aux[i]<=aux[j]) a[k]=aux[i++];//判断大小，选择小的加入数组
            else if(aux[i]>aux[j]) a[k]=aux[j++];
        }
    }

}

• 归并排序最吸引人的性质是它能够保证将任意长度为N的数组排序所需时间和NlogN成正比
• 它的主要缺点是它所需的额外空间和N成正比

 

自底向上的归并排序会多次遍历整个数组，根据子数组大小进行两两归并。比较适合用链表组织的数据

---

快速排序

应用最广泛的排序算法

引人注目的特点是它原地排序（只需要很小的辅助栈），且长度为N的数组排序所需时间和NlgN成正比，以上排序方法都无法将这两个优点结合起来

主要缺点是非常脆弱，在实现时要非常小心才能避免低劣的性能

public class Quick {
    public static void sort(int[] a){
        //此处需要打乱数组顺序，消除对输入的依赖
        sort(a,0,a.length-1);
    }
    private static void sort(int[] a,int lo,int hi){
        if(hi<=lo) return;
        int j=partition(a,lo,hi);
        sort(a,lo,j-1);
        sort(a,j+1,hi);
    }
    private static int partition(int[] a,int lo,int hi){
        int i=lo,j=hi+1;//左右扫描指针
        int v=a[lo];//切分元素
        while(true){
            while(a[++i]<v) if(i==hi) break;
            while(a[--j]>v) if(j==lo) break;
            if(i>=j) break;
            int temp=a[i];
            a[i]=a[j];
            a[j]=temp;
        }
        a[lo]=a[j];
        a[j]=v;
        return j;
    }
}

快速排序自1960年发明以来，很多人都在试图研究并改进他

以下为三种方法

1. 切换到插入排序：对于小数组，插入排序更快，那么可以在对其中一小部分数组排序时切换成插入排序方法
2. 三取样切分：
3. 熵最优的排序: 

---