Java数据结构—排序

最新推荐文章于 2023-04-01 12:11:36 发布
最新推荐文章于 2023-04-01 12:11:36 发布
阅读量395 收藏
点赞数 1
分类专栏： Java数据结构 文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TY_JUST/article/details/121065780
版权

Java数据结构—排序

一、简单排序

1.Comparable接口

Java提供了一个接口Comparable就是用来定义排序顺序规则的。

**需求：**通过Comparable接口提供比较规则，来判断哪个学生年龄大(Student(name,age))

Student类

public class Student implements Comparable<Student>{

    private String name;
    private int 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{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

测试类

ublic class TestComparable {

    private  static Comparable getMax(Comparable c1,Comparable c2){
        return c1.compareTo(c2)>=0?c1:c2;
    }

    public static void main(String[] args) {
        Student student1 = new Student();
        student1.setName("学生1");
        student1.setAge(18);

        Student student2 = new Student();
        student2.setName("学生2");
        student2.setAge(20);

        System.out.println(getMax(student1,student2));


    }
}

输出:

"C:\Program Files\Java\jdk1.8.0_201\bin\java.exe" "-javaagent:C:\软件\IntelliJ IDEA 
Student{name='学生2', age=20}

Process finished with exit code 0

2.冒泡排序

需求：排序前：{4,5,63,2,1} 排序后：{1,2,3,4,5,6}

排序原理：

1.比较相邻的元素，如果一个元素比后一个元素大，就交换这两个元素位置

2.从每对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素，最终最后位置的元素就是最大值。

img

冒泡排序的时间复杂度为：O(N^2)

BubbleSort类：

public class BubbleSort {

    public  void sort(Comparable[] a){
        for (int i=0;i<a.length-1;i++){
            for (int j=0;j<a.length-1-i;j++){
                if (isGreater(a[j],a[j+1])){
                    exchange(a,j,j+1);
                }
            }
        }
    }

    private static boolean isGreater(Comparable c1,Comparable c2){
        return c1.compareTo(c2)>0;
    }

    private static void exchange(Comparable[] a,int i, int j){
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

测试类

public class BubbleSortTest {

    public static void main(String[] args) {
        Integer[] a = {6,5,4,1,2,3};
        BubbleSort bubbleSort = new BubbleSort();
        bubbleSort.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

输出

"C:\Program Files\Java\jdk1.8.0_201\bin\java.exe"
[1, 2, 3, 4, 5, 6]

Process finished with exit code 0

3.选择排序

需求：排序前：{4,5,63,2,1} 排序后：{1,2,3,4,5,6}

排序原理：

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

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

img

SelectSort类：

public class SelectSort {

    public static void sort(Comparable[] a){
        for (int i=0;i<a.length-1;i++){
            int minIndex = i;
            for (int j=i+1;j<a.length;j++){
                if (isGreater(a[minIndex],a[j])){
                    minIndex = j;
                }
            }
            exchange(a,i,minIndex);
        }
    }

    public static boolean isGreater(Comparable c1, Comparable c2){
        return c1.compareTo(c2)>0;

    }

    public static void exchange(Comparable[] a,int i,int j){
        Comparable temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

测试类：

public class SelectSortTest {

    public static void main(String[] args) {
        Integer[] a = {4,5,63,2,1};
        SelectSort.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

输出：

"C:\Program Files\Java\jdk1.8.0_201\bin\java.exe"
[1, 2, 4, 5, 63]

Process finished with exit code 0

选择排序的时间复杂度为：O(N^2)

4.插入排序

插入排序是一种简单直观且稳定的排序算法

需求：排序前：{4,5,63,2,1} 排序后：{1,2,3,4,5,6}

排序原理：

  1. 将所有的元素分为两组，已经排序的和未排序的
  2. 找到未排序的组中第一个元素，向已经排序的组中进行插入
  3. 倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插元素，那么就把待插元素放到这个位置，其他的元素向后移动一位

在这里插入图片描述

InsertSort类：

public class InsertSort {

    public static void sort(Comparable[] a){
        for (int i=1;i<a.length;i++){
            //当前元素为a[i],依次和i之前的元素比较，找到一个小于等于a[i]的元素
            for (int j=i;j>0;j--){
                if (isGreater(a[j-1],a[j])){
                    exchange(a,j-1,j);
                }else {
                    break;
                }
            }
        }
    }

    public static boolean isGreater(Comparable c1, Comparable c2){
        return c1.compareTo(c2)>0;

    }

    public static void exchange(Comparable[] a,int i,int j){
        Comparable temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

测试类：

public class InsertSortTest {

    public static void main(String[] args) {
        Integer[] a = {4,5,63,2,1};
        InsertSort.sort(a);
        System.out.println(Arrays.toString(a));
    }

}

输出结果：

"C:\Program Files\Java\jdk1.8.0_201\bin\java.exe"
[1, 2, 4, 5, 63]

Process finished with exit code 0

排序的时间复杂度为：O(N^2)

二、高级排序

1.希尔排序

需求：排序前：{4,5,63,2,1} 排序后：{1,2,3,4,5,6}

排序原理：

  1. 选定一个增长量h,按照增长量h作为数据分组的依据，对数据进行分组
  2. 对分好的每一组数据完成插入排序
  3. 减少增长量，最小减为1，重复第二步操作
    在这里插入图片描述

增长量h的确定规则

int h = 1;
while(h<数组长度/2){
    h = 2h+1;
}
//循环结束后我们就可以确定h的最大值
//h的减少规则为：
h = h/2;

ShellSort类

public class ShellSort {

    /**
     * 希尔排序
     * @param a
     */
    public  void sort(Comparable[] a){
        //根据数组a的长度,确定增长量h的初始值
        int h = 1;
        while(h<a.length/2){
            h = 2*h+1;
        }
        //希尔排序
        while (h>=1) {
            //找到待插入的元素
            for (int i = h; i < a.length; i++) {
                //把待插入的元素插入到有序数列中
                for (int j = i; j >= h; j -= h) {
                    //待插入元素是a[j],比较a[j]和a[j-h]
                    if (isGreater(a[j - h], a[j])) {
                        exchange(a, j - h, j);
                    } else { //待插入元素已找到合适位置
                        break;
                    }
                }
            }
            //减少h的值
            h = h/2;
        }
    }

    private static boolean isGreater(Comparable c1,Comparable c2){
        return c1.compareTo(c2)>0;
    }

    private static void exchange(Comparable[] a,int i, int j){
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

测试类

public class ShellSortTest {

    public static void main(String[] args) {
        Integer[] a = {1,6,5,7,8,5};
        ShellSort shellSort = new ShellSort();
        shellSort.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

输出结果

"C:\Program Files\Java\jdk1.8.0_201\bin\java.exe"
[1, 5, 5, 6, 7, 8]

Process finished with exit code 0

2.归并排序

**递归：**定义方法的时候，在方法内部调用方法本身，称为递归。

public void show(){
    System.out.println("11232");
    show();
}

**作用：**把大型复杂的问题，层层转换为一个与原问题相似的，规模较小的问题来求解，递归策略只需要少量程序就可以描述解决过程中所需要的多次重复计算，大大地减少了程序的代码量。

**注意事项：**在递归中，不能无限制地调用自己，必须要有边界条件，否则递归层级太深，会造成栈内存溢出。

**归并排序：**归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法，将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序，将两个有序表合并成一个有序表，称为二路归并。

**需求：**排序前：{4,5,63,2,1} 排序后：{1,2,3,4,5,6}

排序原理：

  1. 尽可能的一组拆分成两个元素相等的子组，并对每个子组继续拆分，直到拆分后的每个子组的元素个数是1为止
  2. 将相邻的两个子组进行合并成一个有序的大组
  3. 不断重复步骤2，直到最终有一个组为止

在这里插入图片描述

MergeSort类：

public class MergeSort {

    //归并所需要的辅助数组
    private static Comparable[] assist;

    /**
     * 判断c1是否比c2小
     * @param c1
     * @param c2
     * @return
     */
    private static boolean isLess(Comparable c1,Comparable c2){
        return c1.compareTo(c2)<0;
    }

    /**
     * 交换 a[i] 和 a[j]
     * @param a
     * @param i
     * @param j
     */
    private static void exchange(Comparable[] a,int i, int j){
        Comparable temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    /**
     * 对a排序
     * @param a
     */
    public static void sort(Comparable[] a){
        //初始化数组assist
        assist = new Comparable[a.length];
        //定义lo,hi来记录数组中最小索引和最大索引
        int lo = 0;
        int hi = a.length-1;
        //调用sort重载方法完成数组a中，从索引lo到索引hi的元素排序
        sort(a,lo,hi);
    }

    /**
     * 对a[lo]到a[hi]的元素进行排序
     * @param a
     * @param lo
     * @param hi
     */
    private static void sort(Comparable[] a,int lo, int hi){
        //安全性校验
        if (lo>=hi){
            return;
        }
        //对lo到hi之间的数据分为两组
        int mid = (lo+hi)/2;
        //分别对每组数据进行排序
        sort(a,lo,mid);
        sort(a,mid+1,hi);
        //再把两组数据进行归并
        merge(a,lo,mid,hi);
    }

    /**
     * a[lo]到a[mid]为一组，a[mid+1]到a[hi]为一组,对这两组数据继续归并
     * @param a
     * @param lo
     * @param mid
     * @param hi
     */
    private static void merge(Comparable[] a,int lo,int mid, int hi){
        //定义三个指针
        int i = lo;
        int p1 = lo;
        int p2 = mid+1;

        //遍历，移动p1指针和p2指针，比较对应索引的值，找到小的那一个，放到辅助数组对应的索引处
        while (p1<=mid && p2<=hi){
            //比较索引处的值
            if (isLess(a[p1],a[p2])){
                assist[i++] = a[p1++];
            }else{
                assist[i++] = a[p2++];
            }
        }

        //如果左子组的指针p1没有走完，那么顺序移动p1指针，把对应的元素放在辅助数组的对应索引处
        while (p1<=mid){
            assist[i++] = a[p1++];
        }

        //如果右子组的指针p2没有走完，那么顺序移动p2指针，把对应的元素放在辅助数组的对应索引处
        while (p2<=hi){
            assist[i++] = a[p2++];
        }

        //把辅助数组中的元素拷贝到原数组中
        for (int index=lo;index<=hi;index++){
            a[index] = assist[index];
        }
    }


}

测试类：

public class MergeSortTest {

    public static void main(String[] args) {
        Integer[] a = {4,5,63,2,1} ;
        MergeSort.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

输出结果:

"C:\Program Files\Java\jdk1.8.0_201\bin\java.exe"
[1, 2, 4, 5, 63]

Process finished with exit code 0

归并排序时间复杂度：O(nlogn)

缺点：需要额外分配辅助数组内存空间

3.快速排序

快速排序是对冒泡排序的一种改进，它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据要小，然后再按此方法对两数据分别进行快速排序，这个排序过程可以递归进行，依此达到整个数据变成有序序列

**需求：**排序前：{4,5,63,2,1} 排序后：{1,2,3,4,5,6}

排序原理：

  1. 首先设定一个分界值，通过该分界值将数组分为左右两部分
  2. 将大于或大于分界值的放到数组右边，小于分界值的放到数组左边
  3. 左右边可以独立排序，左边可以取一个分界值，将左边分为两部分，同2；右边也可以做类似处理
  4. 重复上述过程。当左右两部分的数据排好之后，整个数组也就完成了。

在这里插入图片描述

QuickSort类：

public class QuickSort {

    /**
     * 判断c1是否比c2小
     * @param c1
     * @param c2
     * @return
     */
    private static boolean isLess(Comparable c1,Comparable c2){
        return c1.compareTo(c2)<0;
    }

    /**
     * 交换 a[i] 和 a[j]
     * @param a
     * @param i
     * @param j
     */
    private static void exchange(Comparable[] a,int i, int j){
        Comparable temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    /**
     * 对a排序
     * @param a
     */
    public static void sort(Comparable[] a){
        int lo = 0;
        int hi = a.length-1;
        sort(a,lo,hi);
    }

    /**
     * 对a[lo]到a[hi]的元素进行排序
     * @param a
     * @param lo
     * @param hi
     */
    private static void sort(Comparable[] a,int lo, int hi){
        //安全性校验
        if (lo>=hi){
            return;
        }

        //需要对数组中lo索引到hi索引处的元素进行分组（左子组，右子组）
        //返回的是分组的分界值所在的索引，分界值位置变换后的索引
        int partition = getPartition(a,lo,hi);

        //让左子组有序
        sort(a,lo,partition-1);

        //让右子组有序
        sort(a,partition+1,hi);
    }

    /**
     * 对数组a中，从索引lo到索引hi之间的元素进行分组，并返回分组界限对应的索引
     * @param a
     * @param lo
     * @param hi
     */
    private static int getPartition(Comparable[] a,int lo,int hi){
        //分界值
        Comparable key = a[lo];
        //定义两个指针，分别指向待切分数组的最小索引和最大索引
        int left = lo;
        int right = hi+1;

        //切分
        while(true){
            //找到左边比分界值大的数
            while (isLess(a[++left],key)){
                if(left==hi){
                    break;
                }
            }
            //找到右边边比分界值小的数
            while (isLess(key,a[--right])){
                if(right==lo){
                    break;
                }
            }
            if (left >= right){
                break;
            }else {
                exchange(a,left,right);
            }
        }
        //交换分界值
        exchange(a,lo,right);
        return right;
    }
}

测试类：

public class QuickSortTest {

    public static void main(String[] args) {
        Integer[] a = {4,5,63,2,1};
        QuickSort.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

输出结果：

"C:\Program Files\Java\jdk1.8.0_201\bin\java.exe"
[1, 2, 4, 5, 63]

Process finished with exit code 0

快速排序时间复杂度：O(nlogn)

有枫来了
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 数据结构之排序
Junds0的博客
03-25 1041
第1关：选择排序 给定一组无序的数据，如果要把它们从小到大重新排序，我们要如何实现这个排序功能呢？ 本关任务：实现选择排序。 package step1; /** * Created by sykus on 2018/3/20. */ public class SelectionSort { /** * 选择排序 * * @param arr */ public static void sort(int arr[]) { /**
java中的数据结构--排序
flyuniverse_shell的专栏
04-22 2130
注意：包java.util中的类Arrays定义了对数组按升序进行排序的静态方法sort的几个版本。 对于元素是对象的数组，sort使用归并排序。方法： public static void sort(Object[] a); 对整个对象数组a排序，而方法： public static void sort(Object[] a, int first, int last);   包jav
java数据结构-------排序
weixin_64634186的博客
10-24 522
快速排序、冒泡排序、排序
JAVA数据结构和算法：第八章（排序）
春水上行的博客
09-12 1178
#排序排序是我们程序中经常面对的问题，那么排序的严格定义是什么呢？假设含有n个记录的序列为{r1,r2,r3…..,rn}，其对应的关键字分别为{k1,k2,k3…..,kn}，需确定1,2,…..,n的一种排列p1,p2,……..,pn,使其相应的关键字满足Kp1<=Kp2…….<=Kp2(非递减或非递增)关系，即使得序列成为一个按关键字有序的序列{rp1,rp2……rpn}，这样的操作就称为排序
【Java数据结构】常见排序详解
weixin_46913665的博客
02-28 1365
文章目录 一、排序的概念和分类 1.排序的基本概念 2.排序的稳定性 二、常见排序 1.直接插入排序 2.希尔排序 3.简单选择排序 4.堆排序 5.冒泡排序 6.快速排序 6.1.递归快速排序 6.1.1.快排优化 6.2.非递归方式实现 7.归并排序
JAVA数据结构排序动态演示
06-08
在这个"JAVA数据结构排序动态演示"项目中，开发者通过实现一系列经典的排序算法并配合动态界面展示，使学习者能直观地理解各种排序算法的工作原理。 首先，我们来详细解析每个排序算法： 1. **直接插入排序（直接...
java数据结构排序算法之树形选择排序详解
08-30
java数据结构排序算法之树形选择排序详解 树形选择排序是一种高效的排序算法，它可以降低比较次数，提高排序效率。下面我们将详细介绍树形选择排序的原理、实现技巧与相关注意事项。 树形选择排序的原理： 树形...
java数据结构排序算法之归并排序详解
08-30
Java数据结构排序算法之归并排序详解 Java数据结构排序算法之归并排序是基于合并的思想，将两个或两个以上有序表合并成一个新的有序表。这种方法被称作是2-路归并排序（基本操作是将待排序列中相邻的两个有序子...
java数据结构与算法.pdf
01-04
Java作为广泛应用的编程语言，其在实现数据结构和算法时有着丰富的库支持和优秀的可读性。下面将对标题和描述中提到的一些关键知识点进行详细解释。 1. **数据结构**： - **稀疏数组**：当大量数据中大部分为零或...
java 数据结构 PPT课件
07-25
第2章 线性表(java版） 第3章 栈与队列(java版） 第4章 串与数组(Java版) 第5章 树与二叉树(java版） 第6章 图(Java版) 第7章 排序(Java版) 第8章 查找(Java版)
java对数据库数据排序
05-24
通过java语言实现对数据库数据的条件排序，方法比较实用，希望对你能有所帮助
【Java数据结构】排序
weixin_34380948的博客
01-05 123
1.冒泡排序 冒泡排序核心思想: 比较两个元素，如果前一个比后一个大则进行交换。经过对每个元素的比较，最后将最大的元素设置成最后一个元素。重复该操作，最后形成从小到大的排序。for (int i = 0; i < num-1; i++) { for (int j = 0; j < num-i-1; j++) { if(arr[j]&g...
Java数据结构--简单排序
cheng__yu的博客
09-27 132
Java数据结构–简单排序 简单排序是最基本的三种排序方式，包括了冒泡排序、选择排序、插入排序；其中，优化插入排序之后得到了希尔排序。 代码架构 简单排序可通过三个方法都能够很好地实现代码运行，当然也能够直接在一个方法内部构建完毕，多个方法体会看起来更有层次感，简单易懂。 函数名 意义 sort(Comparable[] a) sort函数用来排列数组A中数据，也是整个的核心代码块。 greater(Comparable v, Comparable w) greater函数能够比较其
JAVA数据结构 排序
TTong34的博客
03-26 277
一、概念 1. 排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。平时如果提到排序，通常指的是排升序（非降序）。通常意义上的排序，都是指的原地排序(in place sort)。 2. 两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。 二、七大基于比较的排序 三、插入排序 把整个区间被分为有序区间和无序区间，每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入。实现代码如下： ...
Java数据结构----排序
m0_61801103的博客
04-06 1669
稳定性定义 假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持 不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳 定的；否则称为不稳定的。 插入排序 直接插入排序 直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到 一个新的有序序列 。 当插入第i(i>=1)个元素
数据结构Java版排序（一）
weixin_58850105的博客
02-17 3642
目录 1.概念 1.1稳定性 2.七大排序 2.1插入排序 2.1.1直接插入排序-原理 2.1.2性能分析 2.1.3折半插入排序（了解） 2.2希尔排序 2.2.1原理 2.2.2性能分析 2.3选择排序 2.3.1原理 2.3.2性能分析 2.4堆排序 2.4.1原理 2.4.2性能分析 2.5冒泡排序 2.5.1原理 2.5.2性能分析 2.6快速排序（重要） 2.6.1原理 2.6.2性能分析 1.概念 排序，就是使一串记录，按照其中的某个或某..
Java数据结构之排序
最新发布
ZIYE_190的博客
04-01 416
假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
不得不服！Java实现数据结构中的八种排序方法
m0_46608024的博客
08-04 164
@param data @return */ public void bubbleSort(int[] data){ int i, j; for(i=0;i<data.length-1;i++){ boolean flag = true;//用于判断本次冒泡是否进行了交换 for(j=0;j<data.length-i-1;j++){//第i次排序时最后i个元素已经有序 if(data[j]>data[j+1]){ swap(data, j, j+1);..
数据结构中几种排序的java实现
鹤野云间
08-12 378
1. 选择排序 “` public static int[] selectSort(int[] arrys){ int high=arrys.length; for(int i=0;i **2. 冒泡排序** public static int[] bubbleSort(int[] arrys){ for(int i=0;i&amp;amp;amp;lt;arr...
Java数据结构排序算法解析：冒泡、选择、插入等六种排序
"这篇文档是关于数据结构与算法的，特别是Java实现的排序算法，包括对各种排序算法的比较和稳定性分析。作者通过Markdown格式详细介绍了冒泡排序、选择排序、插入排序、希尔排序、归并排序和快速排序，并提到了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值