排序算法总结

1、Comparable接口

对于排序而言，涉及到大小比较，对于基本类型可以直接比较，而对于对象则需要引入Comparable接口。
例如对于一个人而言，有名字和年龄属性，我们让people这个类实现Comparable接口

public class People implements Comparable<People> {
   private String name;
   private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
//重写比较规则
    @Override
    public int compareTo(People o) {
        return this.age-o.age;
    }

}

测试

public class PeopleTest {
    public static void main(String[] args) {
        People p1=new People();
        p1.setAge(21);
        p1.setName("张三");
        People p2=new People();
        p2.setName("李四");
        p2.setAge(12);
        Comparable max=max(p1,p2);
        System.out.println(max);
    }
    public static Comparable max(Comparable c1,Comparable c2){
        int cmp=c1.compareTo(c2);
        if(cmp>=0){
            return c1;
        }else {
            return c2;
        }
    }
}

2、简单排序

2.1 冒泡排序

冒泡排序的思想非常经典和接近其名字，就像水煮沸后泡泡逐渐变大并上升，冒泡排序每次比较时仅与其相邻的元素作比较，如果元素很大，那么他就会一直后移，第一次冒泡排序完成最大值就会在最后一个位置。

就像上面的这个图片所示，7比4大会跟4互换位置，然后7跟5相邻，7又比5大，就会继续交换位置，直到7到达最后一个位置。
从这个过程中我们可以看出，一次冒泡过程会依次比较相邻两个数最终选出未被排序的数里最大值，放到其所属位置。所以需要进行n-1次冒泡排序。

import java.util.Arrays;

public class BubbleSort  {
    public static void sort(Comparable[] a){
        //进行n-1次冒泡
        for (int i=1;i<a.length;i++){
            //每次冒泡的循环i，此处用前一个跟后一个比
            for (int j=0;j<a.length-i;j++){
                if(greater(a[j],a[j+1])){
                    exch(a,j,j+1);
                }
            }
        }
    }
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable tmp=a[i];
        a[i]=a[j];
        a[j]=tmp;
    }

    public static void main(String[] args) {
        Integer[] a={5,6,8,7,1,2};
        BubbleSort.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

2.2 选择排序

顾名思义，选择，选择，每次从元素中选出此时的最小值，放到前面相应的位置，即第一次选出最小的放在第一个位置，第二次选择第二小的放在第二个位置。如下图所示（此图为黑马的图）

import java.util.Arrays;

public class SelectionSort {
    public static void sort(Comparable[] a){

        for (int i =1; i <a.length; i++) {
            int min=i-1;
            for (int j = i-1; j < a.length-1; j++) {
                if(less(a[j],a[min])){
                    min=j;
                }
            }
            exch(a,i-1,min);
        }
    }
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable tmp=a[i];
        a[i]=a[j];
        a[j]=tmp;
    }

    public static void main(String[] args) {
        Integer[] a={5,6,8,7,1,2};
        BubbleSort.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

2.3插入排序

每次假定前排的元素已经有序，此时选择一个元素，向前比较，放到对应位置。即依次选择第二个元素，第三个元素…放到前面的队列里，找到合适的位置。

import java.util.Arrays;

public class InsertionSort {
        public static void sort(Comparable[] a){
            for (int i =1; i <a.length; i++) {
                for (int j = i; j >0; j--) {
                    if(less(a[j],a[j-1])){
                        exch(a,j,j-1);
                    }
                }
            }
        }
        private static boolean less(Comparable v,Comparable w){
            return v.compareTo(w)<0;
        }
        private static void exch(Comparable[] a,int i,int j){
            Comparable tmp=a[i];
            a[i]=a[j];
            a[j]=tmp;
        }

        public static void main(String[] args) {
            Integer[] a={5,6,8,7,1,2};
            BubbleSort.sort(a);
            System.out.println(Arrays.toString(a));
        }

}

3、高级排序

3.1希尔排序

import java.util.Arrays;

public class Shell {
    public static void sort(Comparable[] a){
        int n=a.length;
        int h=1;
        while (h<n/2){
            h=h*2+1;
        }
        while (h>=1){
            for (int i = h; i <n; i++) {
                for (int j = h; j>=h; j-=h) {
                    if(less(a[j],a[j-h])){
                        exch(a,j,j-h);
                    }
                }
            }
        }
    }
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
    public static void main(String[] args) {
        Integer[] a={5,6,8,7,1,2};
        BubbleSort.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

3.2归并排序

import java.util.Arrays;

public class MergeSort {
    private static Comparable[] assist;
    public static void sort(Comparable[] a){
        int lo=0;
        int hi=a.length-1;
        assist=new Comparable[a.length];
        sort(a,lo,hi);
    }
    public static void sort(Comparable[] a,int lo,int hi){
        if(lo>=hi) return;
        int mid=lo+(hi-lo)/2;
        sort(a,lo,mid);
        sort(a,mid+1,hi);
        merge(a,lo,mid,hi);
    }
    public static void merge(Comparable[] a,int lo,int mid,int hi){
        int p1=lo;
        int p2=mid+1;
        int p=lo;
        while ((p1<=mid)&&(p2<=hi)){
            if (less(a[p1], a[p2])) {
                assist[p++] = a[p1++];
            } else {
                assist[p++] = a[p2++];
            }
        }
        while ((p1 > mid)&&(p<=hi)) {
            assist[p++] = a[p2++];
        }
        while ((p2 > hi)&&(p<=hi)) {
            assist[p++] = a[p1++];
        }
        for (int i = lo; i <=hi ; i++) {
            a[i]=assist[i];
        }
    }
    public static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    public static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }

    public static void main(String[] args) {
        Integer[] a={5,6,8,7,1,2};
        MergeSort.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

3.3快速排序

import java.lang.Comparable;
import java.util.Arrays;

public class QuickSort {
    public static void sort(Comparable[] a){
        int lo=0;
        int hi=a.length-1;
        sort(a,lo,hi);
    }
    private static void sort(Comparable[] a,int lo,int hi){
        if(lo>=hi) return;
        int partition=partition(a,lo,hi);
        sort(a,lo,partition-1);
        sort(a,partition+1,hi);
    }
    private static int partition(Comparable[] a,int lo,int hi){
        Comparable key=a[lo];
        int right=hi+1;
        int left=lo;
        while (true){
            while (less(key,a[--right])){
                if(right==lo)
                break;
            }
            while (less(a[++left],key)){
                 if(left==hi)
                 break;
            }
            if (left>=right){
                break;
            }else{
                exch(a,left,right);
                System.out.println(Arrays.toString(a));
            }
        }
        exch(a,lo,right);
        System.out.println(Arrays.toString(a));
        return right;
    }
    public static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
    public static void exch(Comparable[] a,int i,int j){
        Comparable tmp=a[i];
        a[i]=a[j];
        a[j]=tmp;
    }

    public static void main(String[] args) {
        Integer[] a={5,6,8,7,1,2};
        QuickSort.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

4、时间复杂度及空间复杂度

算法	时间复杂度	空间复杂度	稳定性
冒泡排序	n^2		稳定
选择排序	n^2		不稳定
插入排序	n^2		稳定
希尔排序			不稳定
归并排序	nlogn	额外空间	稳定
选择排序	nlogn(最优) n^2(最坏)		不稳定