【数据结构与算法】排序

最新推荐文章于 2024-06-15 23:36:03 发布
最新推荐文章于 2024-06-15 23:36:03 发布
阅读量90 收藏
点赞数
文章标签： 排序算法 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52061711/article/details/122978440
版权

一、Comparable接口

所有可以排序对象所对应的类，都实现了 Comparable 接口（Comparable 中的泛型为要比较的对象类型，即该类的类型），并重写了compareTo()方法。

public int compareTo(Object obj)

  • 返回值 = 0：this == o
  • 返回值 >0：this > obj
  • 返回值 < 0：this < obj

（1）定义 Student 类

public class Student implements Comparable<Student>{
    private String name;
    private int age;
	
	// 省略 构造器、set、get方法等
	
    @Override
    public int compareTo(Student stu) {
        // 根据年龄比较
        return this.age - stu.age;
    }
}

（2）测试

public class Test {
    public static Comparable getMax(Comparable c1, Comparable c2){
        int result = c1.compareTo(c2);

        if(result >= 0){
            return c1;  // c1大
        }else {
            return c2;
        }
    }

    public static void main(String[] args) {
        Student stu1 = new Student("张三",20);
        Student stu2 = new Student("李四",30);

        Comparable max = getMax(stu1, stu2);
        System.out.println(max); // Student{name='李四', age=30}
    }
}

二、冒泡排序 Bubble

其思想是：相邻的元素两两比较，较大的数下沉，较小的数冒起来。整个过程如同气泡冒起，因此被称作冒泡排序。

  1. 比较相邻的两个元素，如果前一个元素大，就交换位置。
  2. 依次比较每一对，每遍历一次，就会选出一个相对最大的元素（之前已经选出的元素除外）。遍历的总对数是 length - 1。

平均时间复杂度为O(n^2)，适用于元素个数较少的排序。

在这里插入图片描述

public class Bubble {
    /**
     * 对数组 a 排序
     *
     * @param a 数组
     */
    public static void sort(Comparable[] a) {
        // 因为最后一个元素没有下一个，所以第一次遍历的总对数为 length-1，以后每
        // 每次遍历的对数，都要减去已经选出的相对最大值个数
        for (int i = a.length - 1; i > 0; i--) {
            //
            for (int j = 0; j < i; j++) {
                if (isGreater(a[j], a[j + 1])) {
                    swap(a, j, j + 1); // a[j] 大，交换
                }
            }
        }
    }

    /**
     * 判断 v 元素 是否大于 w 元素
     *
     * @param v 元素v
     * @param w 元素w
     * @return 较大元素
     */
    private static boolean isGreater(Comparable v, Comparable w) {
        return v.compareTo(w) > 0;
    }

    /**
     * 数组元素 i 和 j 交换位置
     *
     * @param a 数组
     * @param i 索引i
     * @param j 索引j
     */
    private static void swap(Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

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

public class BubbleSort {
    public static void sort(int[] arr){
        int temp = 0; // 在交换的时候使用

        // 第一轮比较的次数 i 是 length-1, 以后每次都少 1 次
        for (int i = arr.length - 1; i > 0; i--) {
            // 比较次数为 i
            for (int j = 0; j < i; j++) {
                if(arr[j] > arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {5,6,8,2,1,5,6,8};
        BubbleSort.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

三、选择排序 Selection

其思想是：选出相对最小的元素，放在相对最前面（交换）。

  1. 每一次遍历，都假定第一个就是最小元素。在依次与其他元素比较，最终找到最小元素所在的索引。
  2. 最小元素与最前面元素交换。

平均时间复杂度为O(n^2)，适用于元素个数较少的排序。
在这里插入图片描述

public class Selection {
    /**
     * 对数组 a 排序
     *
     * @param a
     */
    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; // a[minIndex] 大，更换索引
                }
            }
            // 交换最小元素所在索引处的值
            swap(a,i,minIndex);
        }
    }

    /**
     * 判断 v 元素 是否大于 w 元素
     *
     * @param v
     * @param w
     * @return
     */
    private static boolean isGreater(Comparable v, Comparable w) {
        return v.compareTo(w) > 0;
    }

    /**
     * 数组元素 i 和 j 交换位置
     *
     * @param a
     * @param i
     * @param j
     */
    private static void swap(Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }


    public static void main(String[] args) {
        Integer[] ints = {4, 6, 8, 7, 9, 2 ,10, 1};
        Selection.sort(ints);
        System.out.println(Arrays.toString(ints));
    }
}

四、插入排序 Insertion

其思想是：将初始数据分为有序部分和无序部分，依次将无序部分的元素插入有序部分中。

  1. 把原始数据分为两组：有序、无序。
  2. 在无序部分中选出一个元素作为待插入元素。
  3. 倒叙遍历有序部分元素，依次和待插入元素比较，直到找到一个元素小于待插入元素，将其放入这个元素的后面（交换），后面元素后移。（利用冒泡思想实现比较并插入）

平均时间复杂度为O(n^2)，适用于元素个数较少的排序。

在这里插入图片描述


public class Insertion {
    /**
     * 对数组 a 排序
     *
     * @param a
     */
    public static void sort(Comparable[] a) {
        // 默认索引为0的元素为有序部分，无序部分从索引1出开始
        for (int i = 1; i < a.length; i++) {
            for (int j = i; j > 0; j--) {
                if (isGreater(a[j-1], a[j])) {
                    swap(a,j,j-1); // a[j-1] 大，交换
                }else {
                    break; // a[j-1] 小，说明已经插入好
                }
            }
        }
    }

    /**
     * 判断 v 元素 是否大于 w 元素
     *
     * @param v
     * @param w
     * @return
     */
    private static boolean isGreater(Comparable v, Comparable w) {
        return v.compareTo(w) > 0;
    }

    /**
     * 数组元素 i 和 j 交换位置
     *
     * @param a
     * @param i
     * @param j
     */
    private static void swap(Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    public static void main(String[] args) {
        Integer[] ints = {4, 3, 2,10,12,1,5,6};
        Insertion.sort(ints);
        System.out.println(Arrays.toString(ints));
    }
}

五、希尔排序 Shell

希尔排序又称为缩小增量排序，是对插入排序的一种优化版本。优化的地方在于：不用每次插入一个元素时，就和有序部分中的所有元素进行比较。

  1. 取一个整数 h 作为间隔，所有距离为 h 的元素为一组。
  2. 每组元素分别排序。
  3. 缩小间隔 h，直至 h = 1。

在这里插入图片描述

间隔 h 的取值：

// 初始值
int h = 1;
while(h < 数组长度 / 2){
	h = 2h + 1;
}

// 减小规则
h = h /2;

public class Shell {
    /**
     * 对数组 a 排序
     *
     * @param a
     */
    public static void sort(Comparable[] a) {

        // 确定间隔初始值
        int h = 1;
        while (h < a.length) {
            h = 2 * h + 1;
        }

        while (h >= 1) {
            // 从第一组中的第二个元素，开始往后依次比较
            for (int i = h; i < a.length; i++) {
                for (int j = i; j >= h; j -= h) {
                    if (isGreater(a[j - h], a[j])) {
                        swap(a, j, j - h); // a[j-h] 大于 插入元素 a[j]
                    }else {
                        break;
                    }
                }
            }
            h = h / 2;
        }
    }

    /**
     * 判断 v 元素 是否大于 w 元素
     *
     * @param v
     * @param w
     * @return
     */
    private static boolean isGreater(Comparable v, Comparable w) {
        return v.compareTo(w) > 0;
    }

    /**
     * 数组元素 i 和 j 交换位置
     *
     * @param a
     * @param i
     * @param j
     */
    private static void swap(Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }


    public static void main(String[] args) {
        Integer[] ints = {9,1,2,5,7,4,8,6,3,5};
        Shell.sort(ints);
        System.out.println(Arrays.toString(ints));
    }
}

六、归并排序 Merge

其思想是：将元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的。

  1. 尽可能将数据分为两个元素个数相等的子组，并对每一个子组继续拆分，直至每组元素个数为1。
  2. 将相邻的两个子组合并，合并过程中进行排序。

平均时间复杂度为O(nlogn) < O(n^2)。

在这里插入图片描述

在这里插入图片描述

public class Merge {

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

    /**
     * 对数组 a 排序
     *
     * @param a
     */
    public static void sort(Comparable[] a) {
        // 初始化辅助数组
        assist = new Comparable[a.length];

        // 开始索引和结束索引
        int start = 0;
        int end = a.length - 1;

        // 排序
        sort(a, start, end);

    }


    /**
     * 对数组 a 中部分元素排序
     *
     * @param a
     * @param start
     * @param end
     */
    private static void sort(Comparable[] a, int start, int end) {
        // 安全性校验
        if (end <= start) {
            return;
        }

        // 分组
        int end1 = start + (end - start) / 2;

        // 对子组排序
        sort(a, start, end1);
        sort(a, end1 + 1, end); // start2 = end1 + 1

        // 归并
        merge(a, start, end1, end);
    }


    /**
     * 把两个子组合并成为一个大组，且排序
     * 两个子组：a[start1.end1], a[start2,end2]
     *
     * @param a
     * @param start1
     * @param end1
     * @param end2
     */
    private static void merge(Comparable[] a, int start1, int end1, int end2) {
        // 定义三个指针
        int i = start1;
        int p1 = start1;
        int p2 = end1 + 1;

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

        // 如果 p1 指针没遍历完
        while (p1 <= end1) {
            assist[i++] = a[p1++];
        }

        // 如果 p2 指针没遍历完
        while (p2 <= end2) {
            assist[i++] = a[p2++];
        }

        // 辅助数组 复制 到原数组
        for (int index = start1; index <= end2; index++) {
            a[index] = assist[index];
        }
    }

    /**
     * 判断 v 元素 是否小于 w 元素
     *
     * @param v
     * @param w
     * @return
     */
    private static boolean isLess(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    public static void main(String[] args) {
        Integer[] ints = {8, 4, 5, 7, 1, 3, 6, 2};
        Merge.sort(ints);
        System.out.println(Arrays.toString(ints));
    }
}

七、快速排序 Quick

快速排序是对冒泡排序的一种改进。

  1. 设定一个分界值（数组第一个元素），将数组分为两部分。
  2. 将小于分界值的元素放到左边，大于或等于分界值的元素放到右边。左边部分总比右边部分小。
  3. 分别继续细分，直到整个数组变成有序序列。

平均时间复杂度为O(nlogn) < O(n^2)。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public class Quick {

    /**
     * 对数组 a 排序
     *
     * @param a
     */
    public static void sort(Comparable[] a) {

        // 开始索引和借宿索引
        int start = 0;
        int end = a.length - 1;

        // 排序
        sort(a, start, end);
    }

    /**
     * 对数组 a 中部分元素排序
     *
     * @param a
     * @param start
     * @param end
     */
    private static void sort(Comparable[] a, int start, int end) {
        // 安全性校验
        if (end <= start) {
            return;
        }

        // 分组，得到分界值所在的索引
        int partition = partition(a, start, end);

        // 对子组排序，不需要对分界值排序
        sort(a, start, partition - 1);
        sort(a, partition + 1, end);
    }

    /**
     * 将 a[start,edn] 进行分组
     *
     * @param a
     * @param start
     * @param end
     * @return 分组分界值所在的索引
     */
    private static int partition(Comparable[] a, int start, int end) {
        // 确定分解值
        Comparable key = a[start];
        // 定义两个指针
        int left = start;
        int right = end + 1;

        // 切分
        while (true) {
            // 从右往左，移动right，找到一个比分界值小的元素
            while (isLess(key, a[--right])) {
                if (right == start) {
                    break;
                }
            }

            // 从左往右，移动left，找到一个比分界值大的元素
            while (isLess(a[++left], key)) {
                if (left == end) {
                    break;
                }
            }

            if (left >= right) {
                break; // 扫描完毕
            } else {
                swap(a, left, right); // 交换，继续扫描
            }
        }
        // 交换分界值
        swap(a, start, right);
        return right;
    }

    /**
     * 判断 v 元素 是否小于 w 元素
     *
     * @param v
     * @param w
     * @return
     */
    private static boolean isLess(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    /**
     * 数组元素 i 和 j 交换位置
     *
     * @param a
     * @param i
     * @param j
     */
    private static void swap(Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    public static void main(String[] args) {
        Integer[] ints = {6, 1, 2, 7, 9, 3, 4, 5, 8};
        Quick.sort(ints);
        System.out.println(Arrays.toString(ints));
    }
}
苹果不肖皮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CompareTo方法的理解及运用，Comparator的使用
qq_41955767的博客
03-09 1495
package arithmetic; import java.util.Arrays; public class CompareDemol { public static void main(String[] args) { Integer i1 = 1; Integer i2 = 2; System.out.println(i1.compareTo(i2));// 比较数值...
Java语言程序设计与数据结构（基础篇）课后练习题 第十三章(1)
2401_83620959的博客
04-10 665
13.4看清单！return 1;return o1;return -1。
String类中的compareTo方法总结
Sturling的博客
07-26 1037
最近我发现了一个事情，那就是在面试笔试中，好多公司都喜欢在String字符串上出问题，涉及到方方面面的知识，包括其中的一些常用方法。在此，我总结下关于String类中的compareTo方法，以备应对以后的笔试面试。 String类的定义： Java.lang  类 String java.lang.Object java.lang.String 所有已实现的接口：Serial
Java String类中的compareTo方法总结
大帅 的CSDN技术尬blog!
09-15 2万+
转载自 https://blog.csdn.net/qq_25827845/article/details/53870329 （http://blog.csdn.net/qq_25827845/article/details/53...
String的compareTo()方法
麦子的博客
10-11 1万+
源码： public int compareTo(String anotherString) { int len1 = value.length; int len2 = anotherString.value.length; int lim = Math.min(len1, len2); char v1[] = value...
C++ 数据结构与算法 排序算法
08-17
本文件将四大排序算法通过“「程序算法之排序」冒泡排序、插入排序、选择排序与快速排序”一文编写出,欢迎下载学习(文章链接:https://blog.csdn.net/Pomelo_ABC/article/details/126015013)
java数据结构与算法.pdf
01-04
包含了各种数据结构和算法（java）的实现方式和详解（图解），包括单双链表、环形链表（约瑟夫问题）、栈、后缀表达式、中缀表达式转后缀表达式、迷宫问题、八大排序算法、多种查找算法、哈希表、二叉树实现以及操作...
合并排序 数据结构 排序算法
12-22
合并排序 数据结构 排序算法
浅谈string中的compareTo方法
热门推荐
kevin的博客
05-23 2万+
今天看了一篇gitchat的文章，标题是 聊聊 Java String 源码的排序算法，从中有所感悟和思考，因此打算总结下自己看的过程中的收获 一，java.lang.Comparable 接口 Comparable 接口强制了实现类对象列表的排序。其排序称为自然顺序，其 compareTo 方法，称为自然比较法 public interface Comparable<T> { ...
两个时间比较
ZZ的博客
01-20 488
import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; /** * 两个时间比较 * @author singlee_zfx * */ public class DateTest { /*时间比大小*/ public static int timeCompa
关于comparator接口和comparable接口以及它们各自的方法compare()和compareTo()
兵马未动，粮草先行。。。的博客
04-11 382
Comparator接口与其compare方法 Comparator接口中具有一个抽象方法，如下： int compare​(T o1, T o2) 比较其两个参数的顺序。 这个方法，只需我们定义，不需要我们调用，底层调用 Collections.sort()源代码调用的， 这个方法的返回值是一个int类型。 return o1-o2是升序 return o...
Java中String类的比较 compareTo()方法详解
weixin_41170125的博客
07-06 3672
compareTo() 方法用于两种方式的比较： 字符串与对象进行比较。 按字典顺序比较两个字符串。 语法 int compareTo(Object o) 或 int compareTo(String anotherString) 参数 o-- 要比较的对象。 anotherString-- 要比较的字符串。 源码 /* *如果参数字符串等于此字符串，则返回值 0； *如果此字符串按字典顺序小于字符串参数，则*返回一个小于 0 的值； *如果此字符串按字典顺序大..
算法学习（一） 基本的排序算法 选择 插入 希尔
开开心心
03-28 182
选择排序、插入、希尔排序，是最基本的排序算法。原理简单，实现容易选择排序的原理是，把一个待排序数组看成是未排序部分，与有序部分，每次在未排序部分选择最大（小）的元素插入有序部分的最后一个位置，当未排序部分长度为0时，整个数组有序，排序结束。选择排序：public class SelectSort { //sort public static &lt;T extends Comparable&l...
String -compareTo()方法
yangkai的博客
11-30 1206
在之前的学习中,始终没有搞清楚String中compareTo()方法的实现原理是什么,今天在复习String的相关知识突然搞清楚了. /* * 按字典顺序比较两个字符串 * int compareTo(String str) * */ public class StringDemo2 { public static void main (String
前端常用排序算法
qq_44242707的博客
06-14 332
【代码】前端常用排序算法。
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 435
【代码】力扣LCP 08.剧情触发时间。
力扣136. 只出现一次的数字
最新发布
LNsupermali的博客
06-15 438
力扣136. 只出现一次的数字
java数据结构与算法排序
09-08
Java提供了多种数据结构和算法排序的实现。以下是一些常见的排序算法： 1. 冒泡排序（Bubble Sort）：通过不断比较相邻元素并交换，将最大（或最小）的元素逐渐“冒泡”到最后（或最前）位置。时间复杂度为O(n^2)。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值