数据结构的六大排序算法详解_排序前 6 8 7 9 0 1 3 2 4 5 第1次划分 5 4 2 3 0 1 6 9 7 8(1)

最新推荐文章于 2024-11-10 20:17:28 发布
最新推荐文章于 2024-11-10 20:17:28 发布
阅读量928 收藏 17
点赞数 18
分类专栏： 程序员 文章标签： 数据结构 排序算法 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84181942/article/details/138440774
版权

一、简单排序

在我们的程序中，排序是非常常见的一种需求，提供一些数据元素，把这些数据元素按照一定的规则进行排序。比如查询一些订单，按照订单的日期进行排序；再比如查询一些商品，按照商品的价格进行排序等等。所以，接下来我们要学习一些常见的排序算法。

在java的开发工具包jdk中，已经给我们提供了很多数据结构与算法的实现，比如List，Set，Map，Math等等，都是以API的方式提供，这种方式的好处在于一次编写，多处使用。我们借鉴jdk的方式，也把算法封装到某个类中，那如果是这样，在我们写java代码之前，就需要先进行API的设计，设计好之后，再对这些API进行实现。

就比如我们先设计一套API如下：

image-20221109154429978

然后再使用java代码去实现它。

1、Comparable接口介绍

由于我们这里要讲排序，所以肯定会在元素之间进行比较，而Java提供了一个接口Comparable就是用来定义排序规则的，在这里我们以案例的形式对Comparable接口做一个简单的回顾。

需求：

  1. 定义一个学生类Student，具有年龄age和姓名username两个属性，并通过Comparable接口提供比较规则；
  2. 定义测试类Test，在测试类Test中定义测试方法Comparable getMax(Comparable c1,Comparable c2)完成测试
//学生类
public class Student implements Comparable<Student>{
    private String username;
    private 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();
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setUsername("zhangsan");
        stu1.setAge(17);
        Student stu2 = new Student();
        stu2.setUsername("lisi");
        stu2.setAge(19);
        Comparable max = getMax(stu1, stu2);
        System.out.println(max);
    }
    //测试方法，获取两个元素中的较大值
    public static Comparable getMax(Comparable c1,Comparable c2){
        int cmp = c1.compareTo(c2);
        if (cmp>=0){
            return c1;
        }else{
            return c2;
        }
    }
}

2、冒泡排序

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

需求：

排序前：{4,5,6,3,2,1}

排序后：{1,2,3,4,5,6}

排序原理：

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

image-20221109173506296

冒泡排序API设计：

image-20221109173617387

冒泡排序的代码实现：

//排序代码
public class Bubble {
    
//对数组a中的元素进行排序

    public static void sort(Comparable[] a){
        for(int i=a.length-1;i>0;i--){
            for (int j = 0; j <i; j++) {
                if (greater(a[j],a[j+1])){
                    exch(a,j,j+1);
                }
            }
        }
    }
    
//比较v元素是否大于w元素

    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }
    
//数组元素i和j交换位置

    private static void exch(Comparable[] a,int i,int j){
        Comparable t = a[i];
        a[i]=a[j];
        a[j]=t;
    }
}
//测试代码
public class Test {
    public static void main(String[] args) {
        Integer[] a = {4, 5, 6, 3, 2, 1};
        Bubble.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

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

3、选择排序

需求：

排序前：{4,6,8,7,9,2,10,1}

排序后：{1,2,4,5,7,8,9,10}

排序原理：

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

image-20221109191758118

选择排序API设计：

image-20221109192014319

选择排序的代码实现：

public class Selection {
    /\*
对数组a中的元素进行排序
\*/
    public static void sort(Comparable[] a){
        for (int i=0;i<=a.length-2;i++){
            //假定本次遍历，最小值所在的索引是i
            int minIndex=i;
            for (int j=i+1;j<a.length;j++){
                if (greater(a[minIndex],a[j])){
                    //跟换最小值所在的索引
                    minIndex=j;
                }
            }
            //交换i索引处和minIndex索引处的值
            exch(a,i,minIndex);
        }
    }
    /\*
比较v元素是否大于w元素
\*/
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }
    /\*
数组元素i和j交换位置
\*/
    private static void exch(Comparable[] a,int i,int j){
        Comparable t = a[i];
        a[i]=a[j];
        a[j]=t;
    }
}
//测试代码
public class Test {
    public static void main(String[] args) {
        Integer[] a = {4,6,8,7,9,2,10,1};
        Selection.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

时间复杂度为 O(N^2)

4、插入排序

需求：

排序前：{4,3,2,10,12,1,5,6}

排序后：{1,2,3,4,5,6,10,12}

排序原理：

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

image-20221109192418406

插入排序代码实现：

public class Insertion {
    /\*
对数组a中的元素进行排序
\*/
    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 (greater(a[j-1],a[j])){
                    //交换元素
                    exch(a,j-1,j);
                }else {
                    //找到了该元素，结束
                    break;
                }
            }
        }
    }
    /\*
比较v元素是否大于w元素
\*/
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }
    /\*
数组元素i和j交换位置
\*/
    private static void exch(Comparable[] a,int i,int j){
        Comparable t = a[i];
        a[i]=a[j];
        a[j]=t;
    }
}

时间复杂度为 O(N^2)

二、高级排序

1、希尔排序

希尔排序是插入排序的一种，又称“缩小增量排序”，是插入排序算法的一种更高效的改进版本。

前面学习插入排序的时候，我们会发现一个很不友好的事儿，如果已排序的分组元素为{2,5,7,9,10}，未排序的分组元素为{1,8}，那么下一个待插入元素为1，我们需要拿着1从后往前，依次和10,9,7,5,2进行交换位置，才能完成真正的插入，每次交换只能和相邻的元素交换位置。那如果我们要提高效率，直观的想法就是一次交换，能把1放到更前面的位置，比如一次交换就能把1插到2和5之间，这样一次交换1就向前走了5个位置，可以减少交换的次数，这样的需求如何实现呢？接下来我们来看看希尔排序的原理。

需求：

排序前：{9,1,2,5,7,4,8,6,3,5}

排序后：{1,2,3,4,5,5,6,7,8,9}

排序原理：

  1. 选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；
  2. 对分好组的每一组数据完成插入排序；
  3. 减小增长量，最小减为1，重复第二步操作。

image-20221109195344071

增长量h的确定：增长量h的值每一固定的规则，我们这里采用以下规则：

int h=1
    while(h<5){
        h=2h+1；//3,7
    }
//循环结束后我们就可以确定h的最大值；
h的减小规则为：
    h=h/2

希尔排序的代码实现：

//排序代码
public class Shell {
    /\*
对数组a中的元素进行排序
\*/
    public static void sort(Comparable[] a){
        int N = a.length;
        //确定增长量h的最大值
        int h=1;
        while(h<N/2){
            h=h\*2+1;
        }
        //当增长量h小于1，排序结束
        while(h>=1){
            //找到待插入的元素
            for (int i=h;i<N;i++){
                //a[i]就是待插入的元素
                //把a[i]插入到a[i-h],a[i-2h],a[i-3h]...序列中
                for (int j=i;j>=h;j-=h){
                    //a[j]就是待插入元素，依次和a[j-h],a[j-2h],a[j-3h]进行比较，如果a[j]小，那么
                    交换位置，如果不小于，a[j]大，则插入完成。
                        if (greater(a[j-h],a[j])){
                            exch(a,j,j-h);
                        }else{
                            break;
                        }
                }
            }
            h/=2;
        }
    }
    /\*
比较v元素是否大于w元素
\*/
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }
    /\*
数组元素i和j交换位置
\*/
    private static void exch(Comparable[] a,int i,int j){
        Comparable t = a[i];
        a[i]=a[j];
        a[j]=t;
    }
}
//测试代码
public class Test {
    public static void main(String[] args) {
        Integer[] a = {9,1,2,5,7,4,8,6,3,5} ;
        Shell.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

注：处理大批量数据时，希尔排序的性能高于插入排序

2、归并排序

关于递归：定义方法时，在方法内部调用方法本身，称之为递归。它通常把一个大型复杂的问题，层层转换为一个与原问题相似的，规模较小的问题来求解。递归策略只需要少量的程序就可以描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

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

在递归中，不能无限制的调用自己，必须要有边界条件，能够让递归结束，因为每一次递归调用都会在栈内存开辟新的空间，重新执行方法，如果递归的层级太深，很容易造成栈内存溢出。

image-20221109230628135

需求：

请定义一个方法，使用递归完成求N的阶乘；

分析：
1!: 1
2!: 2\*1=2\*1!
3!: 3\*2\*1=3\*2!
4!: 4\*3\*2\*1=4\*3!
...
n!: n\*(n-1)\*(n-2)...*2\*1=n\*(n-1)!
所以，假设有一个方法factorial(n)用来求n的阶乘，那么n的阶乘还可以表示为n\*factorial(n-1)

代码实现：

public class Test {
    public static void main(String[] args) throws Exception {
        int result = factorial(5);


![img](https://img-blog.csdnimg.cn/img_convert/7e1ac529546d050d1597aae204b96a08.png)
![img](https://img-blog.csdnimg.cn/img_convert/3f0386c8eea96c04e0977dbae3d65b6f.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

乘还可以表示为n\*factorial(n-1)
> 
> ```
> 
> 


**代码实现：**

public class Test {
public static void main(String[] args) throws Exception {
int result = factorial(5);

[外链图片转存中…(img-Q4pHF8XY-1714802498116)]
[外链图片转存中…(img-vsyEEAco-1714802498117)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84181942
关注
专栏目录
数据结构与算法python—14.排序之九种排序详解
柳杰的博客
05-15 638
文章目录引言一、冒泡排序 引言   排序这部分，会介绍9种基础的排序及其优化 计数排序 基数排序 冒泡排序 桶排序 选择排序 快速排序 插入排序 归并排序 希尔排序 一、冒泡排序   冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。冒泡排序总结来说，就是相邻对比交换位置，直至无需再交换。其动画演示为：
数据结构与算法（二）排序算法详解及实现：选择排序、插入排序、希尔排序、归并排序、快速排序和堆排序
px597的博客
02-05 528
一、测试模板类 在学习排序算法的过程中，初步写了一个测试用的模板类，类的方法中包括排序的算法（待实现），类中目前只实现了小于比较和交换等基础的功能，源代码如下，后续会根据排序算法的不同，实现在模板类的排序方法里。 //sort1.h #pragma once #include <iostream> template<class T> class arrSort { public: arrSort(T* arr1, int length, bool isSorted = false)
基本数据类型排序
mymymyzl的博客
03-18 1163
第一种忽略分类表示，按占用字节表示(少)4byte(字节1) < short(短整型2) = char(字符型2) < int(整型4) = float(单精度4) < double(双精度8) = long(长整型8) 特殊: boolean(布尔类型 未知字节)5# 按类型分(多)6byte(字节1) < short(短整型2) < int(整型4) < long(长整型8),char(字符型2), folat(单精度4) < double(双精度8),.
YTU 快速排序算法
A3208367090的博客
11-20 1261
#include<stdio.h> int arr[10]={6,8,7,9,0,1,3,2,4,5}; void quickSort(int *arr,int begin,int end) { //如果区间不只一个数 if(begin < end) { int temp = arr[begin]; //将区间的第一个数作为基准数 int i = begin; //从左到右进行查找时的“指针”，指示当前左位置 int j = end; //从...
排序及其应用
chj65的博客
01-11 686
数据结构（实验C语言版） 排序及其应用 一、实验目的 （1）掌握在数组上进行各种排序的方法和算法 （2）深刻理解各种方法的特点，并能灵活运用 二、实验环境 硬件环境要求： PC机（单机） 使用的软件名称、版本号以及模块： VS2010或Visual C++ 6.0或Win-TC等。 三、实验内容 设计一个程序，针对关键字序列T={9，8，7，6，5，4，3，2，1，0}，分别利用直接插入排序、希尔...
数据结构八大常见的排序
m0_64146094的博客
03-28 1162
常见排序算法分类 1.插入排序 2.希尔排序(缩小增量排序) 3.选择排序 4.堆排序 5.冒泡排序 6.快速排序（递归和非递归） 7.归并排序
南京邮电大学数据结构实验四（各种内排序算法的实现及性能比较）
06-17
### 数据结构实验四知识点概述 #### 一、实验目的与要求 本次实验旨在通过实践操作，使学生深入了解并掌握各种内排序算法的具体实现方法及其性能分析。具体目标如下： 1. **掌握各种内排序算法的实现方法**：通过...
C++数据结构实验4：查找与排序算法详解及源码
资源摘要信息:"数据结构实验报告(C++) 实验4:查找与排序实验指导（含源码）" 知识点一：二叉排序树的查找操作 在二叉排序树中查找关键字值不小于key的元素值是二叉排序树的基本操作之一。二叉排序树（也称为二叉...
数据结构的六大排序算法详解_排序前 6 8 7 9 0 1 3 2 4 5 第1次划分 5 4 2 3 0 1 6 9 7 8(2)
2401_84181975的博客
05-04 703
冒泡排序的时间复杂度为。
数据结构——八大排序（全）
weixin_48560325的博客
02-09 1万+
排序的基本概念和分类 排序算法的稳定性 概念：假设 Ki=Kj(1<=i<=n,1<=j<<n,i!=j),且在排序前的序列中Ri领先于Rj（即i<j）。如果排序后Ri仍领先于Rj，则说明所用的排序算法是稳定的；反之，若可能使得排序后的序列中Ri领先于Rj，则称所用的排序算法是不稳定的。 内排序和外排序 根据在排序过程中待排序的记录是否全部被放置在内存中，排序分为：内排序和外排序。 内排序实在排序整个过程中，待排序的所有记录全部被放置在内存中。外排序是由于排序记
数据类型优先级顺序
DoNotGoToStudy的博客
02-03 5404
由低到高: byte,short,char—> int —> long—> float —> double
数据结构 数组排序
qq_40270751的博客
11-16 400
#include using namespace std; void SelectSort(int a[],int n)//选择排序法 { for(int i=0; i<n-1; i++) { int index=i;//定义index记录找到的较小值的位置 for(int j=i+1; j<n; j++) { if(a[j]<a[index])//寻找无序区内的最小值
数据结构：常用的几种排序方法
weixin_45054387的博客
03-01 8652
1.冒泡排序 2.选择排序 3.插入排序 4.快速排序 5.希尔排序 6.堆排序
数据结构6-数字排序
yingmu__的博客
08-06 2638
题目6：数字排序 问题描述 　　给定n个整数，请计算每个整数各位数字和，按各位数字和从大到小的顺序输出。 输入格式 　　输入的第一行包含一个整数n，表示给定数字的个数。 　　第二行包含n个整数，相邻的整数之间用一个空格分隔，表示所给定的整数。 输出格式 　　输出多行，每行包含两个整数，分别表示一个给定的整数和它的各位数字和。按各位数字和递减的顺序输出。如果两个整数各位数字和相同，则先输出值较小的，然后输出值较大的。 样例输入 5 101 100 999 1234 110 样例输出 999 27 1234 1
数据结构七种排序算法详解
ReidSC的博客
03-09 3852
  我们通常所说的排序算法往往指的是内部排序算法，即数据记录在内存中进行排序。　　排序算法大体可分为两种：　　　　一种是比较排序，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。　　　　另一种是非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。代码书写的排序法有： 一、冒泡（Bubble）排序——相邻交换冒泡排序是一种极其简单的排序算法，也是我所学的...
数据结构 排序
梦想之深邃
10-03 1390
知识要点： 1、插入排序法(含折半插入排序法)、选择排序法、泡排序法（冒泡排序）、快速排序法、 堆积排序法（堆排序）、归并排序、基数排序等排序方法排序的原理、规律和特点； 2、各种排序算法的时空复杂度的简单分析。 排序的稳定性：排序后不改变原序列中相同元素的相对顺序，则此排序方法是稳定的，反之是不稳定的；                          一般情况下，排序的稳定性与其效率...
数据结构的七种排序
Foreordination_的博客
08-01 802
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序
数据结构-快速排序
热门推荐
3166375975@的博客
08-30 2万+
快速排序 快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。  基本思想：  快速排序使用分治的思想，从待排序序列中选取一个记录的关键字为key，通过一趟排序将待排序列分割成两部分，其中一部分记录的关键字不大于key，另一部分记录的关键字不小于key，之后分别对这两部分记录继续进行...
【01课_初识算法与数据结构】
最新发布
weixin_42333261的博客
11-10 979
算法，个人理解就是计算一段逻辑，最简化，最快速的方式、方法每个函数，就包含了一定的算法，执行一定的计算逻辑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值