数据结构—冒泡排序

Java排序算法

一、排序概述

1、排序的分类

• 插入排序：插入排序、二分法插入排序、希尔排序。
• 选择排序：选择排序、堆排序。
• 交换排序：冒泡排序、快速排序。
• 归并排序
• 基数排序

2、稳定性

​ 也就是说一个序列中的相同值，它排序后，它的相同值的顺序不会改变即稳定。

3、性能

O(n^2):直接插入排序，简单选择排序，冒泡排序。

​ 在数据规模较小时（9W内），直接插入排序，简单选择排序差不多。当数据较大时，冒泡排序算法的时间代价最高。性能为O(n^2)的算法基本上是相邻元素进行比较，基本上都是稳定的。

O(nlogn):快速排序，归并排序，希尔排序，堆排序。

4、排序算法的选择

1.数据规模较小

（1）待排序列基本有序的情况下，可以选择直接插入排序；

（2）对稳定性不作要求宜用简单选择排序，对稳定性有要求宜用插入或冒泡

2.数据规模不是很大

（1）完全可以用内存空间，序列杂乱无序，对稳定性没有要求，快速排序，此时要付出log（N）的额外空间。

（2）序列本身可能有序，对稳定性有要求，空间允许下，宜用归并排序

3.数据规模很大

（1）对稳定性有求，则可考虑归并排序。
（2）对稳定性没要求，宜用堆排序。

4.序列初始基本有序（正序），宜用直接插入，冒泡

二、Comparable排序

API解释

​ 此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。

使用

​ 1、创建实体类生成set/get方法，并实现Comparable接口，重写compareTo方法。

public class Comparable implements java.lang.Comparable<Comparable> {
    private String name;
    private Integer age;

    @Override
    public String toString() {
        return "Comparable{" +
                "name='" + name + '\'' +
                ", age=" + 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 int compareTo(Comparable o) {
        return this.age-o.age;
    }

​ 2、编写代码

package sort;

public class test {
    public static void main(String[] args) {
        Comparable comparable1 = new Comparable();
        Comparable comparable2 = new Comparable();
        comparable1.setAge(18);
        comparable1.setName("张三");
        comparable2.setAge(20);
        comparable2.setName("李四");
        Comparable max = getMax(comparable1, comparable2);
        System.out.println(max);


    }
    public static Comparable getMax(Comparable c1,Comparable c2){
        int i = c1.compareTo(c2);
        if (i>=0){
            return c1;
        }else {
            return c2;
        }
    };
}

三、冒泡排序

​ 1、概念

​ 冒泡排序是一种简单的常见的排序算法，算法重复的走访排序的数组，通过不断的两两比较，最终把最大数浮于上方，好比是可乐的气泡冒泡的过程，所以生动的称之为“冒泡排序”。

​ 2、流程

​ 3、代码

package sort;

import java.util.Arrays;

//冒泡排序
public class maopao {
    public static void main(String[] args) {
        int[] arr={9,5,3,15,18,4,8};
        for (int i=0;i<arr.length;i++){
            for (int j=0;j<arr.length-i-1;j++){
                int num=0;
                if (arr[j]>arr[j+1]){
                    num=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=num;
                }
            }

        }
        System.out.println(Arrays.toString(arr));
    }
}