【算法】排序详解(快速排序,堆排序,归并排序,插入排序,希尔排序,选择排序,冒泡排序)

目录

排序的概念:

排序算法的实现:

插入排序:

希尔排序:

选择排序:

堆排序:

冒泡排序:

快速排序:

快速排序的基本框架:

1.Hoare法

2. 挖坑法

3.前后指针法

 快排的优化:

1. 三数取中法选key

2. 小区间使用插入排序

优化代码:

常见问题:

归并排序:

总结:

结语:


排序的概念:

排序:

所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。

稳定性:

假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持 不变,即在原序列中,r[i]=r[j],且r[i]在r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排序算法是稳 定的;否则称为不稳定的(稳定可以转换成不稳定的,不稳定不可以转换成稳定的)。

内部排序:

数据元素全部放在内存中的排序。

外部排序:

数据元素太多不能同时放在内存中,根据排序过程的要求不能在内外存之间移动数据的排序。

常见的排序算法:

直接插入排序,希尔排序,选择排序,堆排序,冒泡排序,快速排序,归并排序。

排序算法的实现:

说明:由于swap函数经常出现,为了使文章更加整洁,这里给出源码,下文直接调用不在说明。

 private static void swap(int[] array,int i,int j){
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

插入排序:

思路:在待排序的元素中,假设前n-1个元素已有序,现将第n个元素插入到前面已经排好的序列中,使得前n个元素有序。按照此法对所有元素进行插入,直到整个序列有序。

动图演示如下:

代码实现如下:

 public static void insertSort(int[] array){
        for(int i = 1;i < array.length; i++){
            int j = i-1;
            int tmp = array[i];
            for(;j >= 0; j--){
                if(array[j] > tmp){
                    array[j+1] = array[j];
                }else{
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

结果演示:

直接插入排序的特性总结:

1. 元素集合越接近有序,直接插入排序算法的时间效率越高

2. 时间复杂度:O(N^2)

3. 空间复杂度:O(1),它是一种稳定的排序算法

4. 稳定性:稳定

希尔排序:

思路:希尔排序法又称缩小增量法。希尔排序法的基本思想是:先选定一个整数,把待排序文件中所有记录分成多个组,所有距离为的记录分在同一组内,并对每一组内的记录进行排序。然后,取,重复上述分组和排序的工作。当到达 =1时,所有记录在统一组内排好序。

动图演示:

代码实现如下:

在shellSort里面确定组的大小,在shell里面进行排序,通过计算确定gap的关系,间隔运行,一次通过。

 public static void shellSort(int[] array){
        int gap = array.length;
        while(gap > 1){
            gap /= 2;
            shell(array,gap);
        }
    }
    public static void shell(int[] array,int gap){
        for(int i = gap; i < array.length; i++){
            int j = 0;
            j = i-gap;
            int tmp = array[i];
            for(;j >= 0;j -= gap){
                if(array[j] > tmp){
                    array[j+gap] = array[j];
                }else{
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }

结果演示:

希尔排序的特性总结:

1. 希尔排序是对直接插入排序的优化。

2. 当gap > 1时都是预排序,目的是让数组更接近于有序。当gap == 1时,数组已经接近有序的了,这样就会很 快。这样整体而言,可以达到优化的效果。我们实现后可以进行性能测试的对比。

3. 希尔排序的时间复杂度不好计算,因为gap的取值方法很多,导致很难去计算,因此在好些树中给出的希尔排 序的时间复杂度都不固定。

4. 稳定性:不稳定

选择排序:

思路:

(1)在元素集合array[i]--array[n-1]中选择关键码最大(小)的数据元素。

(2)若它不是这组元素中的最后一个(第一个)元素,则将它与这组元素中的最后一个(第一个)元素交换。

(3)在剩余的array[i]--array[n-2](array[i+1]--array[n-1])集合中,重复上述步骤,直到集合剩余1个元素。

动图演示:

代码实现如下:

 //选择排序
    public static void selectSort(int[] array){
        for(int i = 0;i < array.length-1; i++){
            int minIndex = i;
            for(int j = i+1;j < array.length; j++){
                if(array[j] < array[minIndex]){
                    minIndex = j;
                }
            }
            swap(array,i,minIndex);
        }
    }
    private static void swap(int[] array,int i,int j){
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;

    }

结果演示:

选择排序的特性总结 :

1. 直接选择排序思考非常好理解,但是效率不是很好。实际中很少使用

2. 时间复杂度:O(N^2)

3. 空间复杂度:O(1)

4. 稳定性:不稳定

堆排序:

思路:堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆,排降序建小堆。 

动图演示:

代码实现如下:

从小到大用大根堆

从大到小用小根堆

下面代码为大根堆

 public static void heapSort(int[] array){
        createBigHeap(array);
        int end = array.length-1;
        while(end > 0){
            swap(array,0,end);
            siftDown(array,0,end);
            end--;
        }
    }
    private static void createBigHeap(int[] array){
        for(int parent = (array.length - 1 -1)/2; parent >= 0; parent--){
            siftDown(array,parent,array.length);
        }
    }
    private static void siftDown(int[] array,int parent,int end){
        int child = parent*2+1;
        while(child < end) {
            if (child + 1 < end && array[child] < array[child + 1]) {
                child++;
            }
            if (array[child] > array[parent]) {
                swap(array, child, parent);
                parent = child;
                child = parent * 2 + 1;
            } else {
                break;
            }
        }
    }

 结果演示:

堆排序的特性总结:

1. 堆排序使用堆来选数,效率就高了很多。

2. 时间复杂度:O(N*logN)

3. 空间复杂度:O(1)

4. 稳定性:不稳定 

冒泡排序:

简单就不给思路了

动图演示:

 代码实现如下:

public static void bubbleSort(int[] array){
        for(int i = 0; i < array.length - 1; i++){
            boolean flg = false;
            for(int j = 0; j < array.length-1-i; j++){
                if(array[j] > array[j+1]){
                    swap(array,j,j+1);
                    flg = true;
                }
            }
            if(flg == false){
                return;
            }
        }
    }

 结果演示:

冒泡排序的特性总结:

1. 冒泡排序是一种非常容易理解的排序

2. 时间复杂度:O(N^2)

3. 空间复杂度:O(1)

4. 稳定性:稳定 

快速排序:

思路:任取待排序元素序列中的某元 素作为基准值,按照该排序码将待排序集合分割成两子序列,左子序列中所有元素均小于基准值,右子序列中所有元素均大于基准值,然后最左右子序列重复该过程,直到所有元素都排列在相应位置上为止。

快速排序的基本框架:

 //快排的框架
    public static void quickSort(int[] array,int left,int right){
        if(right <= left){
            return;
        }
        int div = partition(array,left,right);
        quickSort(array,left,div-1);
        quickSort(array,div+1,right);
    }

这是还没优化的。

partition可以得到left和right相遇的下标。

关于partition有三种求法分别是Hoare版,挖坑法,前后指针。

其中最常用的是挖坑法。

1.Hoare法

动图如下:

代码实现: 

 //Hoare
    private static int partition(int[] array,int left,int right){
        int i = left;
        int j = right;
        int pivot = array[left];
        while(j > i){
            while(j > i && array[j] >= pivot){
                j--;
            }
            while(j > i && array[i] <= pivot){
                i++;
            }
            swap(array,i,j);
        }
        swap(array,i,left);
        return i;
    }

2. 挖坑法

动图如下:

 代码实现: 

//挖坑法
    private static int partition(int[] array,int left,int right){
        int i = left;
        int j = right;
        int pivot = array[left];
        while(j > i){
            while(j > i && array[j] >= pivot){
                j--;
            }
            array[i] = array[j];
            while(j > i && array[i] <= pivot){
                i++;
            }
            array[j] = array[i];
        }
        array[i] = pivot;
        return i;
    }

3.前后指针法

代码如下:

 //前后指针法
    private static int partition(int[] array,int left,int right){
        int prev = left;
        int cur = left+1;
        while(cur <= right){
            if(array[cur] < array[left] && array[++prev] != array[cur]){
                swap(array,cur,prev);
            }
            cur++;
        }
        swap(array,prev,left);
        return prev;
    }

 快排的优化:

1. 三数取中法选key

使用该优化方法可以有效减少当数组有序时变成单叉树的时间复杂度。

基本思路:选取数组中第一个数,中间数和最后一个数比较大小,将其中中间值和最左边交换,这样可以使mid左后两边数组个数尽可能相等。

代码如下:

private static int middleNum(int[] array,int left,int right){
        int mid = left + ((right - left) >> 1);
        if(array[left] < array[right]){
            if(array[mid] < array[left]){
                return left;
            }else if(array[mid] < array[right]){
                return mid;
            }else{
                return right;
            }
        }else{
            if(array[mid] < array[right]){
                return right;
            }else if(array[mid] < array[left]){
                return mid;
            }else{
                return left;
            }
        }
    }
2. 小区间使用插入排序

思路:我们直到插入排序在数组接近有序时是非常快的,而快排最后在堆上调用的空间是非常大的,故在小区间上使用插入排序可以达到优化的效果。

代码如下:

//优化1
    if(right - left +1 <= 15){
        insertSort2(array,left,right);
        return;
    }
    private static void insertSort2(int[] array,int left,int right){
        if(left >= right){
            return;
        }
        for(int i = 1 + left;i <= right;i++){
            int tmp = array[i];//都定义可读性好
            int j = i-1;
            for(;j >= left;j--){
                if(array[j] > tmp){
                    array[j+1] = array[j];
                }else{
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }
优化代码:

为节省文章长度,下面个代码在上面给出,下面我就不给总代码了(抱歉)。

public static void quickSort(int[] array,int left,int right){
        if(right <= left){
            return;
        }
        //优化1
        if(right - left +1 <= 15){
            insertSort2(array,left,right);
            return;
        }
        //优化2
        int index = middleNum(array,left,right);
        swap(array,index,left);
        int div = partition(array,left,right);
        quickSort(array,left,div-1);
        quickSort(array,div+1,right);
    }

快速排序的特性总结:

1. 快速排序整体的综合性能和使用场景都是比较好的,所以才敢叫快速排序

2. 时间复杂度:O(N*logN)

3. 空间复杂度:O(logN)

4. 稳定性:不稳定

常见问题:

1.在partition 方法中array[j] >= pivot 和 array[i] <= pivot中的等号能否去掉?

答:不能,因为当left和right下标的值等于pivot时会陷入死循环。

2.在partition 方法中能不能先从left开始遍历?

答:不能,因为这样最后和第一个数交换时会把比pivot大的数给到第一个(假设取得pivot取的都是第一个数)

归并排序:

思路:归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使 子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。

图片如下:

 代码实现:

先拆分后合并用递归实现拆分,merge实现合并。

//归并排序
    public static void mergeSort(int[] array,int left,int right){
        if(left >= right){
            return;
        }
        int mid = left + ((right - left) >> 1);
        mergeSort(array,left,mid);
        mergeSort(array,mid+1,right);
        merge(array,left,mid,right);
    }
    private static void merge(int[] array,int left,int mid,int right){
        int s1 = left;
        int s2 = mid + 1;
        int e1 = mid;
        int e2 = right;
        int k = 0;
        int[] tmpArr = new int[right - left + 1];
        while(s1 <= e1 && s2 <= e2){
            if(array[s1] < array[s2]){
                tmpArr[k++] = array[s1++];
            }else{
                tmpArr[k++] = array[s2++];
            }
        }
        while(s1 <= e1){
            tmpArr[k++] = array[s1++];
        }
        while(s2 <= e2){
            tmpArr[k++] = array[s2++];
        }
        for(int i = 0;i < k;i++){
            array[i + left] = tmpArr[i];//特别注意要加left
        }
    }

归并排序总结:

1. 归并的缺点在于需要O(N)的空间复杂度,归并排序的思考更多的是解决在磁盘中的外排序问题。

2. 时间复杂度:O(N*logN)

3. 空间复杂度:O(N)

4. 稳定性:稳定

总结:

重点掌握:快排,堆排,归并,插入。

计数,基数,桶,这三个排序了解即可(代码不会写都没事不考的)

 

结语:

其实写博客不仅仅是为了教大家,同时这也有利于我巩固自己的知识点,和一个学习的总结,由于作者水平有限,对文章有任何问题的还请指出,接受大家的批评,让我改进,如果大家有所收获的话还请不要吝啬你们的点赞收藏和关注,这可以激励我写出更加优秀的文章。

 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/382886.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

RabbitMQ的延迟队列实现[死信队列](笔记一)

关于死信队列的使用场景不再强调&#xff0c;只针对服务端配置 注意&#xff1a; 本文只针对实现死信队列的rabbitMQ基本配置步骤进行阐述和实现 目录 1、docker-compose 安装rabbitMq2、查看对应的版本及插件下载3、安装插件和检测 1、docker-compose 安装rabbitMq a、使用d…

苍穹外卖实操笔记六---缓存商品,购物车功能

苍穹外卖实操笔记六—缓存商品&#xff0c;购物车功能 一.缓存菜品 可以使用redis进行缓存&#xff1b;另外&#xff0c;在实现缓存套餐时可以使用spring cache提高开发效率&#xff1b;   通过缓存数据&#xff0c;降低访问数据库的次数&#xff1b; 使用的缓存逻辑&#…

2.10日学习打卡----初学RocketMQ(一)

2.10日学习打卡 对于MQ(Message queue)消息队列的一些解释可以看我原来写的文章 初学RabbitMQ 各大MQ产品比较 一.RocketMQ概述 发展历程 RocketMQ概念术语 生产者和消费者 生产者负责生产消息&#xff0c;一般由业务系统负责生产消息&#xff0c;消费者即后台系统&…

【从Python基础到深度学习】4. Linux 常用命令

1.配置root用户密码 root用户为系统默认最高权限用户&#xff0c;其他用户密码修改命令与root用户修改密码命令相同 sudo passwd root 2.添加用户&#xff08;henry&#xff09; sudo useradd -m henry -s /bin/bash 3.配置henry用户密码 Xshell下连接新用户&#xff08;hen…

【linux系统体验】-archlinux简易折腾

archlinux 一、系统安装二、系统配置及美化2.1 中文输入法2.2 安装virtualbox增强工具2.3 终端美化2.4 桌面面板美化 三、问题总结3.1 一、系统安装 安装步骤人们已经总结了很多很全: Arch Linux图文安装教程 大体步骤&#xff1a; 磁盘分区安装 Linux内核配置系统&#xff…

vue项目搭建测试

5&#xff0c;项目测试 导入elementplus以及样式 import ElementPlus from element-plus import element-plus/dist/index.csscreateApp(App).use(store).use(router).use(ElementPlus).mount(#app)<template><el-row class"mb-4"><el-button>De…

FPGA_ip_Rom

一 理论 Rom存储类ip核&#xff0c;Rom是只读存储器的简称&#xff0c;是一种只能读出事先存储数据的固态半导体存储器。 特性&#xff1a; 一旦储存资料&#xff0c;就无法再将之改变或者删除&#xff0c;且资料不会因为电源关闭而消失。 单端口Rom: 双端口rom: 二 Rom ip核…

RabbitMQ之五种消息模型

1、 环境准备 创建Virtual Hosts 虚拟主机&#xff1a;类似于mysql中的database。他们都是以“/”开头 设置权限 2. 五种消息模型 RabbitMQ提供了6种消息模型&#xff0c;但是第6种其实是RPC&#xff0c;并不是MQ&#xff0c;因此不予学习。那么也就剩下5种。 但是其实3、4…

(已解决)Vue routes的 children使用(小白来看,包会!)

前言 分析链接&#xff1a;Vueelement ui实现好看的个人中心_vue个人信息页面代码-CSDN博客 使用了很多vue深层知识&#xff0c;简化并且做到自己的项目上面 对小白很有帮助&#xff0c;因为我就是小白&#xff0c;才搞明白。 最核心的就是routes的 children使用&#xff0c…

手把手教你从变量和赋值语句起学python

当你的程序执行计算时&#xff0c;需要把值存储下来以便后面使用。在Python程序中使用变量来存储值。本文你会学到如何定义和使用变量。 为了演示变量的用法&#xff0c;我们会编写一个解决下面问题的程序&#xff1a;在售的软饮料一般分为罐装和瓶装。在商店里&#xff0c;一…

159基于matlab的基于密度的噪声应用空间聚类(DBSCAN)算法对点进行聚类

基于matlab的基于密度的噪声应用空间聚类(DBSCAN)算法对点进行聚类&#xff0c;聚类结果效果好&#xff0c;DBSCAN不要求我们指定集群的数量&#xff0c;避免了异常值&#xff0c;并且在任意形状和大小的集群中工作得非常好。它没有质心&#xff0c;聚类簇是通过将相邻的点连接…

Oracle的学习心得和知识总结(三十二)|Oracle数据库数据库回放功能之论文四翻译及学习

目录结构 注&#xff1a;提前言明 本文借鉴了以下博主、书籍或网站的内容&#xff0c;其列表如下&#xff1a; 1、参考书籍&#xff1a;《Oracle Database SQL Language Reference》 2、参考书籍&#xff1a;《PostgreSQL中文手册》 3、EDB Postgres Advanced Server User Gui…

###C语言程序设计-----C语言学习(11)#数据的存储和基本数据类型

前言&#xff1a;感谢您的关注哦&#xff0c;我会持续更新编程相关知识&#xff0c;愿您在这里有所收获。如果有任何问题&#xff0c;欢迎沟通交流&#xff01;期待与您在学习编程的道路上共同进步。 一. 数据的存储 1.整型数据的存储 计算机处理的所有信息都以二进制形式表示…

Linux防火墙开放

记录一次问题 写的网络服务无法通信 代码没问题&#xff0c;IP绑定、端口绑定没问题&#xff0c;就是无法进行通信&#xff0c;这里要分2步走。 服务器控制台开放 进入防火墙 添加规则&#xff0c;这里以开放udp的8899端口为例 这里在服务器后台就已经开放了&#xff0c;但此时…

人工智能能产生情绪吗?

此图片来源于网络 一、人情绪的本质是什么&#xff1f; 人的情绪本质是一个复杂的现象&#xff0c;涉及到生理、心理和社会的多个层面。以下是关于情绪本质的几种观点&#xff1a; 情绪的本质是生命能量的表达。情绪被认为是生命能量的一种体现&#xff0c;通过情绪的体验和…

Deepin基本环境查看(九)【被封印的创世神】

文章目录 - 相关文章目录1、概述2、Deepin中的创世神和管理员1&#xff09;创世神root2&#xff09;root被封印原因3&#xff09;其他的神灵【管理员】 3、神殿管理【su与sudo】1&#xff09;su&#xff08;Switch User&#xff09;2&#xff09;sudo&#xff08;Superuser Do&…

CTFshow-WEB入门-信息搜集

web1&#xff08;查看注释1&#xff09; wp 右键查看源代码即可找到flag web2&#xff08;查看注释2&#xff09; wp 【CtrlU】快捷键查看源代码即可找到flag web3&#xff08;抓包与重发包&#xff09; wp 抓包后重新发包&#xff0c;在响应包中找到flag web4&#xff08;robo…

re:从0开始的CSS学习之路 9. 盒子水平布局

0. 写在前面 过年也不能停止学习&#xff0c;一停下就难以为继&#xff0c;实属不应 1. 盒子的水平宽度 当一个盒子出现在另一个盒子的内容区时&#xff0c;该盒子的水平宽度“必须”等于父元素内容区的宽度 盒子水平宽度&#xff1a; margin-left border-left padding-lef…

算法学习——LeetCode力扣双指针篇

算法学习——LeetCode力扣双指针篇1 27. 移除元素 27. 移除元素 - 力扣&#xff08;LeetCode&#xff09; 描述 给你一个数组 nums 和一个值 val&#xff0c;你需要 原地 移除所有数值等于 val 的元素&#xff0c;并返回移除后数组的新长度。 不要使用额外的数组空间&#…