【java数据结构】排序，冒泡，插入，选择，希尔，归并，快速

1.1 Comparable排序接口

package demo08sort;

public class Demo01Comparable {
    public static void main(String[] args) {
        Student s1=new Student(49, "李白");
        Student s2=new Student(53,"杜甫");

        Student max = getMax(s1, s2);
        System.out.println(max.getName());

    }
    public static Student getMax(Student s1, Student s2){
        return s1.compareTo(s2)>=0?s1:s2;

    }
}

package demo08sort;

public class Student implements Comparable<Student>{
    private int age;
    private String name;

    public Student() {
    }

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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


    @Override
    public int compareTo(Student o) {
        return this.getAge()-o.getAge();
    }
}

1.2 冒泡排序

package demo08sort;

import java.util.Arrays;

public class Demo02Bubble {
    public static void main(String[] args) {
        int arr[]={2,4,8,6,5};
        Bubble.sort(arr);
        System.out.println(Arrays.toString(arr));

    }
}

package demo08sort;

import java.lang.reflect.Array;
import java.util.Arrays;

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

            }

        }
    }
}

冒泡排序复杂度：O(n方）比较次数+交换次数
1.3 选择排序

package demo08sort;
/*
选择排序
筛选出当前的最小值，交换索引
 */
public class Selection {
    public static void sort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            int index=i;
            for(int j=i;j<arr.length;j++){

                if(arr[index]>arr[j]){
                    index=j;
                }
            }
            int tmp=arr[i];
            arr[i]=arr[index];
            arr[index]=tmp;

        }
    }
}

package demo08sort;

import java.util.Arrays;

public class Demo03Selection {
    public static void main(String[] args) {
        int []arr={3,5,9,8,4,2};
        Selection.sort(arr);
        System.out.println(Arrays.toString(arr));

    }
}

复杂度：O（n方）
1.4 插入排序

package demo08sort;
/*
插入排序
将待排序的数据插入已经排好的数据中
 */
public class Insertion {
    public static void sort(int[] arr){
        for(int i=1;i<arr.length;i++){
            for(int j=i;j>0;j--){
                if(arr[j-1]>arr[j]){
                    int tmp=arr[j-1];
                    arr[j-1]=arr[j];
                    arr[j]=tmp;
                }else {
                    break;
                }
            }
        }
    }
}

package demo08sort;

import java.util.Arrays;

public class Demo04Insertion {
    public static void main(String[] args) {
        int []arr={3,5,9,8,4,2};
        Insertion.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

复杂度：O（n方）
2.高级排序：
2.1 希尔排序

定义增量h，隔着h个增量比较
h的选取规则：初始为1，while(h<n/2) h=2h+1;

package demo08sort;

public class Shell {
    public static void sort(int[] arr){
        int h=1;
        while(h<arr.length/2){
            h=2*h+1;
        }
        while(h>=1){
            for(int i=h;i<=arr.length-h;i++){
                for(int j=i;j>=h;j=j-h){//临界值
                    if(arr[j]<arr[j-h]){
                        int tmp=arr[j];
                        arr[j]=arr[j-h];
                        arr[j-h]=tmp;
                    }else{
                        break;
                    }
                }
            }
            h=h/2;//h要变化
        }
    }
}

package demo08sort;

import java.util.Arrays;

public class Demo05Sort {
    public static void main(String[] args) {
        int[]arr={8,4,9,7,2,5,5,6,3};
        Shell.sort(arr);
        System.out.println(Arrays.toString(arr));

    }
}

希尔排序是特殊的插入排序，用事后分析方法可证明复杂度远远低于插入排序。
2.2 归并排序
递归：调用自己

2.3 快速排序：
找分界值，对分界值的左边和右边分别排序

3.排序稳定性
什么是稳定的排序？相等的值排序后是否交换位置
稳定排序：冒泡排序，插入排序，归并排序
不稳定排序：选择排序，快速排序，希尔排序