8.Java内置排序算法

10. Java内置排序算法

排序算法的分类

1. 如何写一个通用的排序算法
2. 排序元素比较
3. 分治算法思想
   

排序算法选择的建议

O(n²)排序算法的选择

1.插入排序性能最好、其次是选择排序，冒泡排序性能最差

2.选择排序不是稳定的排序算法

3.插入排序是最好的选择

4.对于大规模的乱序数组的排序，可以使用希尔排序

O(nlogn)排序算法的选择

1.快排时间复杂度最坏情况下是O(n2)，合理选择分区点

2.归并排序在任何情况下的时间复杂度都是O(nlogn)

3.归并排序的空间复杂度是O(n)，快排空间复杂度是O(nlogn)

4.但是快排不是稳定的排序算法，归并排序是稳定的排序算法

O(n)排序算法的选择

都是对数据有要求的

1.桶排序：桶与桶之间有序、元素均匀的划分到桶中

2.计数排序：应用在数据范围不大的场景

3.基数排序：排序数据可以分割出独立的"位"而且每一位的数据范围不能太大

O(n²)排序算法对比O(nlogn)排序算法

如何写一个通用的排序算法

1. 不能选择线性时间复杂度的桶排序、计数排序、基数排序
2. 小规模数据，可以使用O(n2)的插入排序
3. 大规模数据，可以使用O(nlogn)的排序算法

Java内置的排序算法Arrays.sort(int[] data)

1. 对于小数据量（小于47）的话使用插入排序
2. 然后小数据量（大于47而小于286）的话使用递归实现的快速排序
3. 对于大数据量使用迭代（自底朝上）实现的归并排序

引用类型实现Comparable可比较

1. 基本类型数据比较：天然支持，< > <= >=
2. 引用类型数据比较
   a. java.lang.Comparable

//实现Comparable接口，重写compareTo方法
@Override
public int compareTo(Person o) {
    if(this.age<o.age){
        //说明当前对象比o对象小
        //实际上只要是返回负数就可以，不一定是-1
        return -1;
    }else if(this.age>o.age){
        //说明当前对象比o对象大
        //实际上只要是返回正数就可以，不一定是-1
        return 1;
    }
    //说明当前对象和o对象一样大
    return 0;
}

//等同于
@Override
public int compareTo(Person o) {
    return this.age - o.age;    //升序
}

b.java.util.Comparator

Comparator<Person> comparator1 = new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.getAge()-o2.getAge();
    }
};
int compare1 = comparator1.compare(p1, p2);
System.out.println(compare1);

引用类型数组排序

package com.xiaoyi.line.algo.sort.compare;

import com.xiaoyi.line.algo.sort.Sorter;

import java.util.Arrays;
import java.util.Comparator;

public class ThreeWayQuickSorter<E extends Comparable<E>> extends Sorter {
    public void sort(E[] data) {
        if (data == null || data.length <= 1) return;
        sort(data, 0, data.length - 1);
    }

    private void sort(E[] data, int lo, int hi) {
        if (lo >= hi) return;
        // 分区
        E pivot = data[hi];

        int less = lo;
        int great = hi;

        int i = lo;
        while (i <= great) {
            if (data[i].compareTo(pivot) < 0) {
                swap(data, i, less);
                less++;
                i++;
            } else if (data[i].compareTo(pivot) > 0) {
                swap(data, i, great);
                great--;
            } else {
                i++;
            }
        }

        sort(data, lo, less - 1);
        sort(data, great +1, hi);
    }

    //使用比较器比较
    public void sort(E[] data, Comparator<E> c) {
        if (data == null || data.length <= 1) return;
        sort(data, 0, data.length - 1, c);
    }

    private void sort(E[] data, int lo, int hi, Comparator<E> c) {
        if (lo >= hi) return;
        // 分区
        E pivot = data[hi];

        int less = lo;
        int great = hi;

        int i = lo;
        while (i <= great) {
            if (c.compare(data[i], pivot) < 0) {
                swap(data, i, less);
                less++;
                i++;
            } else if (c.compare(data[i], pivot) > 0) {
                swap(data, i, great);
                great--;
            } else {
                i++;
            }
        }

        sort(data, lo, less - 1, c);
        sort(data, great +1, hi, c);
    }

    public static void main(String[] args) {
        Person p1 = new Person("douma", 40);
        Person p2 = new Person("laotang", 30);
        Person p3 = new Person("douma1", 32);
        Person p4 = new Person("laotang2", 33);
        Person[] people = new Person[]{p1, p2, p3, p4};
        Comparator<Person> comparator = ((o1, o2) -> o2.getAge() - o1.getAge());
        new ThreeWayQuickSorter().sort(people, comparator);
        System.out.println(Arrays.toString(people));
    }
}

Java内置排序算法

引用类型数组排序强调使用稳定排序算法，因此不能用快排

public class JavaSorter {

    public static void main(String[] args) {
        int[] data = new int[]{12,23,36,9,24,42};
        Arrays.sort(data); // 通用的排序
        System.out.println(Arrays.toString(data));

        Person p1 = new Person("douma", 40);
        Person p2 = new Person("laotang", 30);
        Person p3 = new Person("douma1", 32);
        Person p4 = new Person("laotang2", 33);
        Person[] people = new Person[]{p1, p2, p3, p4};
        //Arrays.sort(people);
        Comparator<Person> comparator = ((o1, o2) -> o1.getAge() - o2.getAge());
        //Arrays.sort(people, comparator);
        // 小规模数据的话选择插入排序
        // 大规模数据的话选择归并排序
        //      (老版本使用的是递归实现的归并，而新版本使用的则不是递归实现的归并)
        //System.out.println(Arrays.toString(people));

        ArrayList<Person> list = new ArrayList<>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        //动态数组排序
        Collections.sort(list, comparator);
        // 底层：Arrays.sort
        System.out.println(list);
    }
}