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
java 复制代码
//实现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

java 复制代码
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);

引用类型数组排序

java 复制代码
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内置排序算法

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

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);
    }
}
相关推荐
前行的小黑炭9 分钟前
设计模式:为什么使用模板设计模式(不相同的步骤进行抽取,使用不同的子类实现)减少重复代码,让代码更好维护。
android·java·kotlin
Java技术小馆15 分钟前
如何设计一个本地缓存
java·面试·架构
XuanXu1 小时前
Java AQS原理以及应用
java
罗西的思考2 小时前
[2W字长文] 探秘Transformer系列之(23)--- 长度外推
人工智能·算法
风象南4 小时前
SpringBoot中6种自定义starter开发方法
java·spring boot·后端
mghio13 小时前
Dubbo 中的集群容错
java·微服务·dubbo
咖啡教室18 小时前
java日常开发笔记和开发问题记录
java
咖啡教室18 小时前
java练习项目记录笔记
java
鱼樱前端18 小时前
maven的基础安装和使用--mac/window版本
java·后端