【数据结构与算法】第三章：简单排序

于 2021-09-15 07:12:34 发布
阅读量140 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/tu_wer/article/details/120300619
版权

3.1、Comparable接口介绍

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

案例：

  1. 定义一个学生类Student，有年龄age和姓名username两个属性，并通过Comparable接口提供比较规则
  2. 定义测试类Test，在测试类Test中定义测试方法Comparable getMax(Comparable c1,Comparable c2)
    完成测试
public class ComparableTest {
    public static void main(String[] args) {
        Student student1 = new Student();
        student1.setUserName("张三");
        student1.setAge(18);

        Student student2 = new Student();
        student2.setUserName("李四");
        student2.setAge(20);

        System.out.println(compare(student1, student2));
    }

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

class Student implements Comparable<Student> {
    public String userName;
    public int age;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getAge() {
        return age;
    }

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

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

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

Student{userName='李四', age=20}

3.2、冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法

案例：

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

  • 排序原理

    1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置
    2. 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值

  • API设计

  • 代码实现
public class BubbleSort {
    /**
     * 比较次数
     */
    private static int n1 = 0;
    /**
     * 交换次数
     */
    private static int n2 = 0;
    
    public static void main(String[] args) {
        Integer[] c = {4, 5, 6, 3, 2, 1};
        System.out.println("排序前：" + Arrays.toString(c));
        sort(c);
        System.out.println("排序后：" + Arrays.toString(c));
        System.out.println("比较次数：" + n1);
        System.out.println("交换次数：" + n2);
        
    }

    /**
     * 排序
     *
     * @param c
     */
   public static void sort(Comparable[] a) {
        // 数组长度
        int n = a.length;
        // 需要比较的总趟数(冒泡次数): n-1
        for (int i = n - 1; i > 0; i--) {
            System.out.print("【第" + (n - i) + "趟】");
            int x = 0;
            int y = 0;
            // 单趟比较次数: i
            // j从1开始，一直到i
            // 用j前面的元素和j处的元素比较
            for (int j = 1; j <= i; j++) {
                x++;
                // 比较并交换
                if (greater(a[j-1], a[j])) {
                    y++;
                    exch(a, j-1, j);
                }
            }
            System.out.print("比较：" + x + "次");
            System.out.print(" 交换：" + y + "次");
            System.out.println();
        }
    }

    /**
     * 比较 c1 是否大于 c2
     *
     * @param c1
     * @param c2
     * @return
     */
    private static boolean greater(Comparable c1, Comparable c2) {
        return c1.compareTo(c2) > 0;
    }

    /**
     * 交换数组c中位置i和j处的元素
     *
     * @param c 目标数组
     * @param i 交换索引
     * @param j 交换索引
     */
    private static void exch(Comparable[] c, int i, int j) {
        if (c[i] != c[j]) {
            Comparable temp = c[i];
            c[i] = c[j];
            c[j] = temp;
        }
    }
}

排序前：[6, 3, 5, 4, 2, 1]
【第1趟】比较：5次 交换：5次
【第2趟】比较：4次 交换：3次
【第3趟】比较：3次 交换：2次
【第4趟】比较：2次 交换：2次
【第5趟】比较：1次 交换：1次
排序后：[1, 2, 3, 4, 5, 6]
比较次数：15
交换次数：13

  • 时间复杂度分析

    • 冒泡排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析冒泡排序的时间复杂度，主要分析一下内层循环体的执行次数即可。

    • 在最坏情况下，也就是假如要排序的元素为{6,5,4,3,2,1}逆序，那么：元素比较的次数为：

      (N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2

      元素交换的次数为：

      (N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2

      总执行次数为：

      (N^2 /2 -N/2) + (N^2 /2-N/2) = N^2-N

    • 按照大O推导法则，保留函数中的最高阶项，那么最终冒泡排序的时间复杂度为： O(N^2) (平方阶)

3.3、选择排序

选择排序是一种更加简单直观的排序方法

案例：

  • 需求： 排序前：{4,6,8,7,9,2,10,1} 排序后：{1,2,4,5,7,8,9,10}

  • 排序原理

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

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

  • API设计

  • 代码实现
public class SelectionSort {
    public static void main(String[] args) {
        Integer[] c = {4,6,8,7,9,2,10,1};
        System.out.println("排序前：" + Arrays.toString(c));
        sort(c);
        System.out.println("排序后：" + Arrays.toString(c));
    }
    /**
     * 排序
     * @param c
     */
    public static void sort(Comparable[] c) {
        // 最小元素所在位置
        int minIndex;
        // 选择趟数
        for (int i = 0; i < c.length - 1; i++) {
            // 定义一个变量，记录最小元素所在的素引；默认为参与排序的第一个元素的所在索引
            minindex = i;
            // 每一趟中的比较次数，找出这一趟中参与排序的最小元素j
            for (int j = i + 1; j < c.length; j++) {
                // 比较minindex与j位置的值
                if (greater(c[minindex], c[j])) {
                    minindex = j;
                }
            }
            // 交换索引位置为i、minindex的值
            if(minindex != i){
           	 	exch(c, i, minindex);
            }            
        }
    }

    /**
     * 比较 c1 是否大于 c2
     *
     * @param c1
     * @param c2
     * @return
     */
    private static boolean greater(Comparable c1, Comparable c2) {
        return c1.compareTo(c2) > 0;
    }

    /**
     * 交换数组c中位置i和j处的元素
     *
     * @param c 目标数组
     * @param i 交换索引
     * @param j 交换索引
     */
    private static void exch(Comparable[] c, int i, int j) {
        if (c[i] != c[j]) {
            Comparable temp = c[i];
            c[i] = c[j];
            c[j] = temp;
        }
    }
}

排序前：[4, 6, 8, 7, 9, 2, 10, 1]
排序后：[1, 2, 4, 6, 7, 8, 9, 10]

  • 时间复杂度分析

    • 选择排序使用了 双层for循环，其中外层循环完成了数据交换，内层循环完成了数据比较，所以我们分别统计数据交换次数和数据比较次数：

      数据比较次数：

      (N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2 /2 - N/2;

      数据交换次数：

      N-1

      时间复杂度：N^2 /2 - N/2+（N-1）=N^2 /2 + N/2 - 1

    • 根据大O推导法则，保留最高阶项，去除常数因子，时间复杂度为：O(N^2) （平方阶）

3.4、插入排序

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

插入排序的工作方式非常像人们排序一手扑克牌一样。
开始时，我们的左手为空并且桌子上的牌面朝下。然后，我们每次从桌子上拿走一张牌并将它插入左手中正确的位置。为了找到一张牌的正确位置，我们从右到左将它与已在手中的每张牌进行比较，如下图所示：

案例：

  • 需求: 排序前：{4,3,2,10,12,1,5,6} 排序后：{1,2,3,4,5,6,10,12}

  • 排序原理：

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

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

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

  • API设计

  • 代码实现
public class InsertionSort {
    public static void main(String[] args) {
        Integer[] c = {4,3,2,10,12,1,5,6};
        System.out.println("排序前：" + Arrays.toString(c));
        sort(c);
        System.out.println("排序后：" + Arrays.toString(c));
    }
    /**
     * 排序
     *
     * @param c
     */
    public static void sort(Comparable[] c) {
        // 未排序元素
        for(int i=1;i<c.length;i++){
            // 取出未排序元素中的第一个，依次与已排序元素比较(倒序)，找出合适的位置插入
            for(int j=i;j>0;j--){
                if(greater(c[j-1],c[j])){
                    // 前面大于后面，交换位置
                    exch(c,j-1,j);
                }else{
                    // 前面不大于后面，退出内循环
                    break;
                }
            }
        }
    }

    /**
     * 比较 c1 是否大于 c2
     *
     * @param c1
     * @param c2
     * @return
     */
    private static boolean greater(Comparable c1, Comparable c2) {
        return c1.compareTo(c2) > 0;
    }

    /**
     * 交换数组c中位置i和j处的元素
     *
     * @param c 目标数组
     * @param i 交换索引
     * @param j 交换索引
     */
    private static void exch(Comparable[] c, int i, int j) {
        if (c[i] != c[j]) {
            Comparable temp = c[i];
            c[i] = c[j];
            c[j] = temp;
        }
    }
}

排序前：[4, 3, 2, 10, 12, 1, 5, 6]
排序后：[1, 2, 3, 4, 5, 6, 10, 12]
  • 时间复杂度分析
    • 插入排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析插入排序的时间复杂度，主要分析一下内层循环体的执行次数即可
    • 最坏情况，也就是待排序的数组元素为{12,10,6,5,4,3,2,1}，那么：
      比较的次数为：
      (N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2 = N^2/2-N/2
      交换的次数为：
      (N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)(N-1)/2 = N^2/2-N/2
      总执行次数为：
      (N^2 /2 - N/2) + (N^2 /2-N /2) = N^2-N
    • 按照大O推导法则，保留函数中的最高阶项，时间复杂度为：O(N^2) （平方阶）

3.5、比较

排序思路单遍比较次数单遍交换次数稳定性时间复杂度
冒泡从前向后，一遍一遍，两两比较
每一遍都使最大的放在后面		多次
（最多n-1）		多次
（最多n-1）		稳定O(N^2)
平方阶
选择从前向后，一遍一遍，两两比较
每一遍都找出最小的放在前面
多次
（最多n-1）		一次不稳定O(N^2)
平方阶
插入把数组分为有序、无序两组
从无序组中取第一个，插入
(倒序比较)到有序中合适的位置
直至无序组为空		多次
（最多n-1）		多次
（最多n-1）		稳定O(N^2)
平方阶

选择排序中，因为每一遍比较中只找出最小元素的位置，比较完之后，把最小元素和本次比较中的最前面元素交换，仅此一次

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

土味儿~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值