一、简单排序

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

目录

前言

一、Comparable接口介绍

1.描述

2.Comparable使用

 二、冒泡排序

1.排序原理

2.冒泡排序实现

2.1 冒泡排序API

2.2 冒泡排序实现

3.冒泡排序时间复杂度

三、选择排序

1.排序原理

2.选择排序实现

2.1 选择排序API

2.2 选择排序实现

3.选择排序时间复杂度

四、插入排序

1.排序原理

2.插入排序实现

2.1 插入排序API

2.2 插入排序实现

3.插入排序时间复杂度

总结

---

前言

提示：这里可以添加本文要记录的大概内容：

自学JAVA数据结构笔记，跟学视频为：黑马程序员Java数据结构与java算法全套教程，数据结构+算法教程全资料发布，包含154张java数据结构图_哔哩哔哩_bilibili

---

一、Comparable接口介绍

1.描述

JAVA提供了一个用来定义排序规则的接口Comparable

2.Comparable使用

需求：

1.定义一个学生类Student，具有年龄age和姓名username两个属性，并通过Comparable接口提供比较规则；

2.定义测试类Test，在测试类Test中定义测试方法Comparable getMax(Comparable c1,Comparable c2)完成测试

代码：

学生类：

package ComparableTest;

//学生类
public class Student implements Comparable<Student>{
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "username='" + name + '\'' +
                ", age=" + age +
                '}';

    }

    //重写接口内部方法
    @Override
    public int compareTo(Student o) {
        return this.getAge() - o.getAge();
    }

}

测试类：

package ComparableTest;

public class Test {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",20);

        Comparable max = getMAx(s1,s2);

        System.out.println(max);


    }
    //比较
    public static Comparable getMAx(Comparable c1,Comparable c2){

        int result = c1.compareTo(c2);
        if(result >= 0){
            return c1;
        }else{
            return c2;
        }

    }

}

注：

在输出Compar类型数据时，需要重写toString()方法 

 二、冒泡排序

1.排序原理

1.比较相邻的元素，如果前一位数比当前数大，则交换这两个元素

2.对每一对元素执行1操作，直到最后一对元素

2.冒泡排序实现

2.1 冒泡排序API

类名 ：        Bubble

构造方法 ： Bubble()：创建Bubble对象

成员方法 ：1.public static void sort(Comparable[] a)：对数组内的元素进行排序

                    2.private static boolean greater(Comparable v,Comparable w):判断v是否大于w                     3.private static void exch(Comparable[] a,int i,int j)：交换a数组中，索引i和索引j处的值

2.2 冒泡排序实现

排序类：

package sort;

public class Bubble {

    //对数组内的元素进行排序
    public static void sort(Comparable[] nums){

        for(int i = 0;i < nums.length - 1;i ++){
            for(int j = 0;j < nums.length - 1 - i;j ++){
                //如果当前元素比后一个元素大，则交换两个元素
                if(greater(nums[j],nums[j + 1])){
                    exch(nums,j,j + 1);
                }
            }
        }

    }

    //判断v是否大于w
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w) > 0;
    }

    //交换
    private static void exch(Comparable[] nums,int i,int j){
        Comparable temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

---

测试类：

package sort;

import java.util.Arrays;

public class BubbleTest {
    public static void main(String[] args) {

        Integer[] nums = {3,6,7,9,0,1,4,2,5,8};
        Bubble.sort(nums);
        System.out.println(Arrays.toString(nums));

    }

}

3.冒泡排序时间复杂度

 冒泡排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，其时间复杂度为：O(N^2).

三、选择排序

1.排序原理

1.每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引

2.交换第一个索引处和最小值所在的索引处的值

2.选择排序实现

2.1 选择排序API

类名 ：        Selection

构造方法 ： Selection()：创建Selection对象

成员方法 ： 1.public static void sort(Comparable[] a)：对数组内的元素进行排序                                        2.private static boolean greater(Comparable v,Comparable w):判断v是否大于w                     3.private static void exch(Comparable[] a,int i,int j)：交换a数组中，索引i和索引j处的值

2.2 选择排序实现

排序类：

package sort;

public class Selection {
    public static void sort(Comparable[] nums){

        for(int i = 0;i < nums.length - 1;i ++){
            //假定最小值索引
            int minIndex = i;
            //假定第一个元素i处的值为最小值，则将i+1之后的元素与i处的比较，并找出最小值
            for(int j = i + 1;j < nums.length;j ++){
                if(greater(nums[minIndex],nums[j])){
                    //如果minIndex处的值比j的大，则更新最小值
                    minIndex = j;
                }
            }

            //在第一次遍历结束之后，并找出最小值，则交换i处与最小值元素
            exch(nums,i,minIndex);
        }

    }

    //判断v是否大于w
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w) > 0;
    }

    //交换
    private static void exch(Comparable[] nums,int i,int j){
        Comparable temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

}

测试类：

package sort;

import java.util.Arrays;

public class SelectionTest {
    public static void main(String[] args) {

        Integer[] nums = {3,6,7,9,0,1,4,2,5,8};
        Selection.sort(nums);
        System.out.println(Arrays.toString(nums));

    }

}

3.选择排序时间复杂度

选择排序使用了双层for循环，其中外层循环完成了数据交换，内层循环完成了数据比较，其时间复杂度为O(N^2);

四、插入排序

1.排序原理

1.把所有的元素分为两组，已经排序的和未排序的；

2.找到未排序的组中的第一个元素，向已经排序的组中进行插入；

3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他的元素向后移动一位；

2.插入排序实现

2.1 插入排序API

类名：         Insertion

构造方法： Insertion()：创建Insertion对象

成员方法： 1.public static void sort(Comparable[] a)：对数组内的元素进行排序

                   2.private static boolean greater(Comparable v,Comparable w):判断v是否大于w                    3.private static void exch(Comparable[] a,int i,int j)：交换a数组中，索引i和索引j处的值

2.2 插入排序实现

排序类：

package sort;

public class Insertion {
    public static void sort(Comparable[] nums){

       for(int i = 1;i < nums.length;i ++){
           //当前元素为a[i],依次和i前面的元素比较，找到一个小于等于a[i]的元素
           for(int j = i;j > 0;j --){
               if(greater(nums[j - 1],nums[j])){
                   exch(nums,j - 1,j);
               }else{
                   break;
               }
           }
       }
    }

    //判断v是否大于w
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w) > 0;
    }

    //交换
    private static void exch(Comparable[] nums,int i,int j){
        Comparable temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

}

测试类：

package sort;

import java.util.Arrays;

public class InsertionTest {
    public static void main(String[] args) {

        Integer[] nums = {3,6,7,9,0,1,4,2,5,8};
        Insertion.sort(nums);
        System.out.println(Arrays.toString(nums));

    }

}

3.插入排序时间复杂度

插入排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，其时间复杂度为：O(N^2)

总结

提示：这里对文章进行总结：