八大排序算法 - Java实现

冒泡排序

排序原理：

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

 代码实现：

import java.util.Arrays;public class BubbleSort {public static void main(String[] aaa) {int[] a=new int[]{5,2,4,3,1,8,6,7};sort(a);System.out.print(Arrays.toString(a));}public static void sort(int[] a) {for(int i=0;i<a.length-1;i++){			for(int j=0;j<a.length-1-i;j++){if(a[j]>a[j+1]){int temp=a[j];a[j]=a[j+1];a[j+1]=temp;}}}}
}

时间复杂度分析：

        冒泡排序使用了双层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)

选择排序

排序原理：

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

代码实现：

import java.util.Arrays;public class SearchSort {public static void main(String[] aaa) {int[] a=new int[]{5,2,4,3,1,8,6,7};sort(a);System.out.print(Arrays.toString(a));}public static void sort(int[] a) {//第一层循环，控制遍历次数for(int i=0;i<a.length-1;i++){//min记录最小的数int min=a[i];//minNum记录最小的数的下标，用于下面的交换int minNum=i;//第二层循环，遍历比较出最小值for(int j=i+1;j<a.length;j++){if(min>a[j]){min=a[j];minNum=j;}}//将最小值移动到最前面a[minNum]=a[i];a[i]=min;}}
}

时间复杂度分析：

选择排序使用了双层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)

插入排序

排序原理：

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

代码实现：

import java.util.Arrays;public class InsertSort {public static void main(String[] aaa) {int[] a=new int[]{1,3,12,5,3,123,5,4676,54};System.out.println(Arrays.toString(a));sort(a);System.out.println(Arrays.toString(a));}public static void sort(int[] a){for(int i=1;i<a.length;i++){for(int j=i;j-1>=0;j--){if(a[j-1]>a[j]){int temp=a[j-1];a[j-1]=a[j];a[j]=temp;}else break;}}}}

 时间复杂度分析：

插入排序使用了双层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)

快速排序

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

排序原理：

  1. 首先设定一个分界值，通过该分界值将数组分成左右两部分。
  2. 将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
  3. 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
  4. 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。

切分原理：

     把一个数组切分成两个子数组的基本思想：

  1. 找一个基准值，用两个指针分别指向数组的头部和尾部；
  2. 先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置；
  3. 再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置；
  4. 交换当前左边指针位置和右边指针位置的元素；
  5. 重复2,3,4步骤，直到左边指针的值大于右边指针的值停止；

 代码实现：

import java.util.Arrays;public class QuickSort {public static void main(String[] args) {int[] a=new int[]{50,23,88,35,65,53,90,13,52,42,16,18,73,25,77,66};System.out.println(Arrays.toString(a));sort(a,0,a.length-1);System.out.println(Arrays.toString(a));}public static void sort(int[] a,int b,int e){if(b>=e) return;int i=b;int j=e;while(i<j) {if(a[i]>a[i+1]) {int temp=a[i];a[i]=a[i+1];a[i+1]=temp;i++;}else {int temp=a[j];a[j]=a[i+1];a[i+1]=temp;j--;}}sort(a,b,i-1);sort(a,i+1,e);}}

时间复杂度分析：

快速排序的一次切分从两头开始交替搜索，直到left和right重合，因此，一次切分算法的时间复杂度为O(n),但整个快速排序的时间复杂度和切分的次数相关。

最优情况：每一次切分选择的基准数字刚好将当前序列等分。

 如果我们把数组的切分看做是一个树，那么上图就是它的最优情况的图示，共切分了logn次，所以，最优情况下快速排序的时间复杂度为O(nlogn);

最坏情况：每一次切分选择的基准数字是当前序列中最大数或者最小数，这使得每次切分都会有一个子组，那么总共就得切分n次，所以，最坏情况下，快速排序的时间复杂度为O(n^2);

平均情况：每一次切分选择的基准数字不是最大值和最小值，也不是中值，这种情况我们可以用数学归纳法证明，快速排序的时间复杂度为O(nlogn);

希尔排序

排序原理：

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

代码实现：

import java.util.Arrays;public class ShellSort {public static void main(String[] args) {int[] a=new int[]{5,2,4,35,13,1,8,6,32,7,543};System.out.println(Arrays.toString(a));sort(a);System.out.println(Arrays.toString(a));}public static void sort(int[] a){for(int gap=a.length/2;gap>0;gap/=2){for(int i=gap;i<a.length;i++){for(int j=i;j-gap>=0;j--){if(a[j-gap]>a[j]){int temp=a[j-gap];a[j-gap]=a[j];a[j]=temp;}else break;}}}}
}

时间复杂度分析：

在希尔排序中，增长量h并没有固定的规则，有很多论文研究了各种不同的递增序列，但都无法证明某个序列是最好的，因此对于希尔排序不做时间复杂度分析

归并排序

排序原理：

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

 归并原理：

代码实现：

import java.util.Arrays;public class MergeSort1 {public static void main(String[] args) {int[] a=new int[]{50,23,88,35,65,53,90,13,52,42,16,18,73,25,77,66};System.out.println(Arrays.toString(a));sort(a,0,a.length-1);System.out.println(Arrays.toString(a));}public static void sort(int[] a,int l,int r){if(l==r) return;int mid=(l+r)/2;sort(a,l,mid);sort(a,mid+1,r);int[] temp=new int[r-l+1];int i=0;int s1=l;int s2=mid+1;while(s1<=mid && s2<=r){if(a[s1]<a[s2]){temp[i]=a[s1];s1++;i++;}else {temp[i]=a[s2];s2++;i++;}}while(s1<=mid){temp[i]=a[s1];s1++;i++;}while(s2<=r){temp[i]=a[s2];s2++;i++;}for(int i1=0;i1<temp.length;i1++){a[l+i1]=temp[i1];}}
}

时间复杂度分析：

用树状图来描述归并，如果一个数组有8个元素，那么它将每次除以2找最小的子数组，共拆log8次，值为3，所以树共有3层,那么自顶向下第k层有2^k个子数组，每个数组的长度为2^(3-k)，归并最多需要2^(3-k)次比较。因此每层的比较次数为 2^k * 2^(3-k)=2^3,那么3层总共为 3*2^3。

假设元素的个数为n，那么使用归并排序拆分的次数为log2(n),所以共log2(n)层，那么使用log2(n)替换上面3*2^3中的3这个层数，最终得出的归并排序的时间复杂度为：log2(n)*2^(log2(n))=log2(n)*n,根据大O推导法则，忽略底数，最终归并排序的时间复杂度为O(nlogn);

堆排序

 堆可以分为大根堆，小根堆

大根堆:每个节点的值都大于或者等于他的左右孩子节点的值

小根堆:每个结点的值都小于或等于其左孩子和右孩子结点的值0

堆是用数组完成数据元素的存储的，由于数组的底层是一串连续的内存地址，所以我们要往堆中插入数据，我们只能往数组中从索引0处开始，依次往后存放数据，但是堆中对元素的顺序是有要求的，每一个结点的数据要大于等于它的两个子结点的数据，所以每次插入一个元素，都会使得堆中的数据顺序变乱，这个时候我们就需要通过一些方法让刚才插入的这个数据放入到合适的位置。

以大根堆的调整为例：

同样，删除元素也需要进行堆调整：

对于大根堆，索引1处的元素，也就是根结点是最大的元素，当我们把根结点的元素删除后，需要有一个新的根结点出现，这时我们可以暂时把堆中最后一个元素放到索引1处，充当根结点，但是它不满足大根堆的有序性需求，这个时候我们就需要通过一些方法，让这个新的根结点放入到合适的位置。

堆排序实现步骤（使用大根堆，实现从小到大排序）：

  1. 构造大根堆；
  2. 得到堆顶元素，这个值就是最大值；
  3. 交换堆顶元素和数组中的最后一个元素，此时所有元素中的最大元素已经放到合适的位置；
  4. 对堆进行调整，重新让除了最后一个元素的剩余元素中的最大值放到堆顶；
  5. 重复2~4这个步骤，直到堆中剩一个元素为止；
public class HeapSort {public static void main(String[] args) {int[] a=new int[]{5,32,4,23,1,8,64,67,35,85,12,123,543,45,23,10};System.out.println(Arrays.toString(a));int l=a.length;for(int i=0;i<a.length-1;i++){for(int p=l-1;p>=0;p--){sort(a,p,l);}int temp=a[0];a[0]=a[l-1];a[l-1]=temp;l--;}System.out.println(Arrays.toString(a));}public static void sort(int[] a,int p,int l){int c=2*p+1;if(c<l){int rc=c+1;if(rc<l && a[c]<a[rc]) c=rc;if(a[p]<a[c]){int temp=a[p];a[p]=a[c];a[c]=temp;p=c;sort(a,p,l);}}}}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Liunx系统编程：进程信号的概念及产生方式

Liunx系统编程：进程信号的概念及产生方式

目录 一. 进程信号概述 1.1 生活中的信号 1.2 进程信号 1.3 信号的查看 二. 信号发送的本质 三. 信号产生的四种方式 3.1 按键产生信号 3.2 通过系统接口发送信号 3.2.1 kill -- 向指定进程发送信号 3.2.2 raise -- 当自身发送信号 3.2.3 abort -- 向自身发送进程终止…
阅读更多...
【ES5和ES6】数组遍历的各种方法集合

【ES5和ES6】数组遍历的各种方法集合

一、ES5的方法 1.for循环 let arr [1, 2, 3] for (let i 0; i < arr.length; i) {console.log(arr[i]) } // 1 // 2 // 32.forEach() 特点&#xff1a; 没有返回值&#xff0c;只是针对每个元素调用func三个参数&#xff1a;item, index, arr &#xff1b;当前项&#…
阅读更多...
嵌入式Linux开发实操（八）：UART串口开发

嵌入式Linux开发实操（八）：UART串口开发

串口可以说是非常好用的一个接口，它同USB、CAN、I2C、SPI等接口一样，为SOC/MCU构建了丰富的接口功能。那么在嵌入式linux中又是如何搭建和使用UART接口的呢？ 一、Console接口即ttyS0 ttyS0通常做为u-boot(bootloader的一种，像是Windows的BIOS)，它需要一个交互界面，一般…
阅读更多...
HTML中的字符串转义

HTML中的字符串转义

为什么要转义&#xff1f; 转义可以防止 xss 攻击。接下来&#xff0c;我们来看一下如何转义。 HTML Sanitizer API Sanitizer 是浏览器自带的转义方法&#xff0c;在2021年初被提出&#xff0c;兼容性问题很大。 列举几个常用的 API&#xff1a; const $div document.qu…
阅读更多...
C++------利用C++实现二叉搜索树【数据结构】

C++------利用C++实现二叉搜索树【数据结构】

文章目录 二叉搜索树概念二叉搜索树的操作查找插入删除 二叉搜索树的应用 二叉搜索树 概念 什么是二叉搜索树&#xff0c;二叉搜索树就是指左孩子永远比根小右孩子永远比根大。这个规则适用于所有的子树。 上面的就是一棵二叉搜索树&#xff0c;我们还可以发现这棵树走一个中…
阅读更多...
Windows安装 Elasticsearch 教程

Windows安装 Elasticsearch 教程

下载地址 Past Releases of Elastic Stack Software | Elastic 解压 解压完的样子 进入BIN目录 D:\Develop\elasticsearch\elasticsearch-7.12.0\bin 按住shift 鼠标右键 打开 powershell 窗口 查看ES版本 .\elasticsearch.bat --version 出现问题了 警告&#xff1a;不赞成…
阅读更多...
如何学习专业的学术用语01

如何学习专业的学术用语01

问题的提出——凭啥人家写的词汇这么专业 做法一 做法二&#xff1a;做一个专业数据库 专门做教育技术类的
阅读更多...
React(6)

React(6)

1.React插槽 import React, { Component } from react import Child from ./compoent/Childexport default class App extends Component {render() {return (<div><Child><div>App下的div</div></Child></div>)} }import React, { Compon…
阅读更多...
（二）结构型模式：4、组合模式（Composite Pattern）（C++实例）

（二）结构型模式：4、组合模式（Composite Pattern）（C++实例）

目录 1、组合模式&#xff08;Composite Pattern&#xff09;含义 2、组合模式应用场景 3、组合模式的优缺点 4、组合模式的UML图学习 5、C实现组合模式的简单示例&#xff08;公司的OA系统&#xff09; 1、组合模式&#xff08;Composite Pattern&#xff09;含义 组合模…
阅读更多...
Visual Studio 如何放大代码字体的大小

Visual Studio 如何放大代码字体的大小

1.打开Visual Studio&#xff0c;新建一个程序&#xff0c;一段代码&#xff0c;为接下去的操作做好准备。单击菜单栏的【工具】选项。 2.在跳出来菜单中找到【选项】&#xff08;一般在最后一项&#xff09;&#xff0c;然后单击。跳出新的窗口。 3.跳出新的窗口后&#xff…
阅读更多...
Leetcode 0814周总结

Leetcode 0814周总结

本周刷题&#xff1a; 88, 108, 121, 219, 228, 268, 283, 303, 349, 350, 414, 448 88 合并两个有序数组 nums1{1, 2, 3 ,0, 0, 0} nums2{2, 5, 6} 合成效果&#xff1a;nums1{1, 2, 2, 3, 5, 6} 思路&#xff1a;【双指针】对两个数组设置双指针&#xff0c;依次比较哪…
阅读更多...
无涯教程-TensorFlow - 单词嵌入

无涯教程-TensorFlow - 单词嵌入

Word embedding是从离散对象(如单词)映射到向量和实数的概念&#xff0c;可将离散的输入对象有效地转换为有用的向量。 Word embedding的输入如下所示: blue: (0.01359, 0.00075997, 0.24608, ..., -0.2524, 1.0048, 0.06259) blues: (0.01396, 0.11887, -0.48963, ..., 0.03…
阅读更多...
【Docker】Docker安装 MySQL 8.0，简洁版-快速安装使用

【Docker】Docker安装 MySQL 8.0，简洁版-快速安装使用

今天&#xff0c;使用docker安装mysql数据库进行一个测试&#xff0c;结果网上找了一篇文章&#xff0c;然后。。。。坑死我… 特总结本篇安装教程&#xff0c;主打一个废话不多说&#xff01; 坑&#xff1a;安装成功&#xff0c;客户端工具连接不上数据库》。。。 正文&…
阅读更多...
【蓝桥杯】[递归]母牛的故事

【蓝桥杯】[递归]母牛的故事

原题链接&#xff1a;https://www.dotcpp.com/oj/problem1004.html 目录 1. 题目描述 2. 思路分析 3. 代码实现 1. 题目描述 2. 思路分析 我们列一个年份和母牛数量的表格&#xff1a; 通过观察&#xff0c;找规律&#xff0c;我们发现&#xff1a; 当年份小于等于4时&…
阅读更多...
js 小程序限流函数 return闭包函数执行不了

js 小程序限流函数 return闭包函数执行不了

问题&#xff1a; 调用限流 &#xff0c;没走闭包的函数&#xff1a; checkBalanceReq&#xff08;&#xff09; loadsh.js // 限流 const throttle (fn, context, interval) > {console.log(">>>>cmm throttle", context, interval)let canRun…
阅读更多...
〔011〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇

〔011〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇

✨ 目录 🎈 脸部崩坏🎈 下载脸部修复插件🎈 启用脸部修复插件🎈 插件生成效果🎈 插件功能详解🎈 脸部崩坏 相信很多人在画图时候，特别是画 有多个人物 图片或者 人物在图片中很小 的时候，都会很容易出现面部崩坏的问题这是由于神经网络无法完全捕捉人脸的微妙细节…
阅读更多...
opencv进阶09-视频处理cv2.VideoCapture示例（打开本机电脑摄像头）

opencv进阶09-视频处理cv2.VideoCapture示例（打开本机电脑摄像头）

视频信号&#xff08;以下简称为视频&#xff09;是非常重要的视觉信息来源&#xff0c;它是视觉处理过程中经常要处理的一类信号。实际上&#xff0c;视频是由一系列图像构成的&#xff0c;这一系列图像被称为帧&#xff0c;帧是以固定的时间间隔从视频中获取的。获取&#xf…
阅读更多...
透视俄乌网络战之一：数据擦除软件

透视俄乌网络战之一：数据擦除软件

数据擦除破坏 1. WhisperGate2. HermeticWiper3. IsaacWiper4. WhisperKill5. CaddyWiper6. DoubleZero7. AcidRain8. RURansom 数据是政府、社会和企业组织运行的关键要素。数据擦除软件可以在不留任何痕迹的情况下擦除数据并阻止操作系统恢复摧&#xff0c;达到摧毁或目标系统…
阅读更多...
FreeRTOS源码分析-12 低功耗管理

FreeRTOS源码分析-12 低功耗管理

目录 1 STM32低功耗管理概念及应用 1.1睡眠模式 1.2 停止模式 1.3 待机模式 2 Tickless低功耗管理 2.1 Tickless低功耗模式介绍 2.2 FreeRTOS低功耗模式配置 2.3 FreeRTOS低功耗模式应用 3 低功耗管理实际项目开发 3.1 低功耗设计必须要掌握的硬件知识 …
阅读更多...
Debian11 Crontab

Debian11 Crontab

Crontab用户命令 可执行文件 crontab命令的可执行文件在哪儿&#xff1f; $ which -a crontab /usr/bin/crontab /bin/crontabcrontab命令的可执行文件有2个&#xff1a;/usr/bin/crontab 和 /bin/crontab $ diff /usr/bin/crontab /bin/crontab $diff 发现这两个文件并无区…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023