排序算法（Java实现）
2024-04-05 18:50:43
1、插入排序
直接插入排序
时间复杂度O{n^2}
package 排序.插入排序.直接插入排序;/*** 插入排序 -- 每次从后面选择一个数与前面排好序的数组进行比较，如果小，进行交换并与前面继续比较，如果大学，结束，并且不交换* 两层for循环* 第一层： 确定有序数组，* 第二层： 使用下一个数与前面的有序数组比较，确定合适的位置*/
public class InsertSorted {/*** 这个方法每次比较成功都会执行三次赋值，性能略差* @param arr*/public static void sort(int[] arr) {for (int i = 1; i < arr.length; i++) { //从1开始，因为第一个arr[0]已经有序for (int j = i; j >=1 && arr[j] < arr[j-1]; j--) { //不断与前面有序数组比较，确定合适位置int temp = arr[j]; //执行交换arr[j] = arr[j-1];arr[j-1] = temp;}}}//时间复杂度 O{n^2}/*** 改进的插入排序* @param*/public static void sort2(int[] arr) {for (int i = 1; i < arr.length; i++) {int j; //保存可以插入的位置int temp = arr[i]; //需要插入的元素for (j = i; j >=1 && temp < arr[j-1]; j--) { //不断与前面有序数组比较，确定合适位置arr[j] = arr[j-1]; //向后赋值}arr[j] = temp;}}public static void main(String[] args) {int[] arr = {10, 9, 8, 7, 50, 5, 4, 3, 2, 1};InsertSorted.sort2(arr);for(int i = 0; i < arr.length; i ++) {System.out.print(arr[i] + " ");}}
}折半插入排序
时间复杂度O{n^2}(查找次数减少，移动次数不变)
package 排序.插入排序.折半插入排序;public class InsertSorted {public static void sort(int[] arr) {for (int i = 1; i < arr.length; i ++) {int temp = arr[i]; //定义临时变量保存需要插入的值int low = 0, high = i - 1;while (low <= high) {int mid = (low + high) / 2;if (temp < arr[mid]) high = mid - 1; //条件没有小于，如果有会发生不稳定else low = mid + 1;} //high的后一个位置就是插入的位置//需要插入的位置是high+1,for (int j = i; j > high + 1; j --) {arr[j] = arr[j-1];}arr[high + 1] = temp;}}/*** 时间复杂度，O(n^2)* 虽然采用了折半插入，但是仅仅在查找过程中时间复杂度为O(log2n),因为减少了关键字的比较* 但是在数据移动时的复杂度任然为O(n^2),* 但是在性能上还是优于直接插入排序* @param args*/public static void main(String[] args) {int[] arr = {10, 9};InsertSorted.sort(arr);for(int i = 0; i < arr.length; i ++) {System.out.print(arr[i] + " ");}}
}希尔排序(缩小增量排序)
增量一般为n/2…
时间复杂度约为O{n^1.3}
package 排序.插入排序.希尔排序;/*** 希尔排序：缩小增量排序，(不稳定）* 原理：直接插入排序在 （基本有序，记录较少） 的情况下有较好的性能*/
public class InsertSorted {public static void sort(int[] arr) {int d = arr.length / 2; //这就是缩小增量的过程while (d > 0) {for (int i = d; i < arr.length; i ++) {int temp = arr[i];int j;for (j = i; j >= d && temp < arr[j - d]; j = j - d) {arr[j] = arr[j - d]; //后移}arr[j] = temp;}d = d / 2 ;}}public static void main(String[] args) {int[] arr = {10, 9, 8, 7, 50, 5, 4, 3, 2, 1};InsertSorted.sort(arr);for(int i = 0; i < arr.length; i ++) {System.out.print(arr[i] + " ");}}
}2、交换排序
冒泡排序(几乎不用)
时间复杂度O{n^2}
package 排序.交换排序.冒泡排序;public class ExchangeSorted {/*** 时间复杂度O(n^2),性能较差，交换次数较多，几乎不用* @param arr*/public static void sort(int[] arr) {boolean flag = true; //设置一个监视哨，如果在某一趟排序中未发生交换，说明该序列已经有序，可以跳出外层循环；int m = arr.length;for (int i = 0; i < arr.length && flag; i ++){flag = false;for (int j = 0; j < m - 1; j ++) { //第一趟选择最大的，第二趟选择次大的，以此类推。。。。。。if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;flag = true;}}m--; //因为每一趟都会选出一个最大的值，所以不需要再次向后面进行比较}}public static void main(String[] args) {int[] arr = {10, 9, 8, 7, 50, 5, 4, 3, 2, 1};ExchangeSorted.sort(arr);for(int i = 0; i < arr.length; i ++) {System.out.print(arr[i] + " ");}}
}快速排序
时间复杂度O{nlog2n}（2为底）
package 排序.交换排序.快速排序;/*** 时间复杂度O(log2n)* 在冒泡排序中，一次交换只能消除一个逆序，而快速排序间隔多个记录进行交换可能消除多个逆序* 原理：选择一个pivot（枢轴），经过一趟排序后，将小于pivot的放到pivot前面，将大于pivot的放到pivot后面,* 就可以确定该pivot在数组中的位置（通常选择第一个记录为pivot）\\* 适用于初始无序，n较大时* （不稳定排序）*/
public class QuickSorted {public static void sort(int[] arr ,int start, int end) {int left = start,right = end;int pivot = arr[left];if (left >= right) return; //递归出口的条件，当区间大于零的时候才继续执行while (left < right) { //一趟排序，结束条件是当left指针和right指针相遇//必须从右边开始扫描，因为左端的值已经放到了临时变量pivot中，可以进行覆盖，//如果从左边开始扫描，就会将右端的值覆盖，发生丢失while (left < right && arr[right] >= pivot) right --; //如果右边的值大于等于pivot，指针左移arr[left] = arr[right];while (left < right && arr[left] <= pivot) left ++; //如果左边的值小于等于pivot，指针右移arr[right] = arr[left];}arr[left] = pivot; //此时left = right，这个位置就是pivot（arr[start]）应该在的位置sort(arr, start, left - 1); //递归调用函数，这是左区间sort(arr, left + 1, end); //递归调用函数，这是右区间}public static void main(String[] args) {int[] arr = {10, 9, 8, 7, 50, 5, 4, 3, 5, 1};sort(arr,0,arr.length - 1);for(int i = 0; i < arr.length; i ++) {System.out.print(arr[i] + " ");}}
}3、选择排序
简单选择排序
时间复杂度O{n^2}
package 排序.选择排序.简单选择排序;/*** 选择排序，每次都从未排序中选择最小的放到最前面，* 利用两层循环* 第一层for循环用于选择确定需要选择最小值的数量* 第二层循环用于找出剩余数据的最小值* 采用寻找最小值下标的方法*/
public class SelectedSorted {public static void sort(int[] arr) { //传入数组for (int i = 0; i < arr.length; i++) { //第一层循环,每次都设当前循环位置为最小值位置int minIndex = i;for (int j = i + 1; j < arr.length; j++) { //第二层循环，遍历除上一层循环位置后的所有值，if (arr[j] < arr[minIndex]) { //与最小值位置的值相比较,不断找到最小值得位置，知道循环完成minIndex = j;}}int temp = arr[minIndex]; //定义临时变量，存放最小值arr[minIndex] = arr[i]; //将第一层循环所在位置的值赋给当前最小值所在的位置，完成交换arr[i] = temp; //将最小值赋给第一层循环所在位置}}/*** 时间复杂度 为 O{n^2}* @param args*/public static void main(String[] args) {int[] arr = new int[]{10, 9, 8, 7, 50, 5, 4, 3, 2, 1};SelectedSorted.sort(arr);for(int i = 0; i < arr.length; i ++) {System.out.print(arr[i] + " ");}}
}堆排序
时间复杂度O(nlog2n)，空间复杂度O(1) 
package 排序.选择排序.堆排序;public class HeapSorted {/*** 筛选法建立堆（大根堆）* @param arr 传入的数组* @param start 需要调整堆的起始位置* @param end 需要调整堆的结束位置* 我采用的是数组下标从零开始的数组，建立* 的堆也是从0开始的，* 所以（cur ！= 2*start）而是（cur = 2 * start + 1）*/public void heapAdjust(int[] arr, int start, int end) { //为数组的start位置到end位置调整堆int temp = arr[start]; //使用临时变量保存arr[start]（就是第一个元素）int cur; //用来指向起始位置(start)的下一个位置for (cur = 2 * start + 1; cur <= end; cur = 2 * start + 1) {//当cur指向最后一个元素（cur = end）时，就不需要再判断arr[cur] < arr[cur + 1]了，因为没有arr[cur + 1],//如果条件为cur < end && arr[cur] < arr[cur + 1]，会发生数组越界if (cur < end && arr[cur] < arr[cur + 1]) cur++;if (temp >= arr[cur]) break; //如果temp（arr[start]>=arr[cur]），跳出循环，不再往下进行比较arr[start] = arr[cur]; //否则元素上移start = cur; //并且start位置下移}arr[start] = temp;}/*** 建初堆* @param arr （传入需要建初堆的数组)** 建立完初堆后，根节点为最大值*/public void creatHeap(int[] arr) {int n = arr.length;//因为数组下标从0开始，所以（n / 2 - 1）为第一个需要调整堆的位置，大于（n / 2 - 1)的位置为叶子节点，符合堆的定义for (int i = n / 2 - 1; i >= 0; --i) { //根节点也需要调整堆，所以i >= 0;heapAdjust(arr, i, n - 1); //最后一个元素位置为 n -1 ；}}/*** 堆排序* @param arr (需要堆排序的数组)*/public void heapSort(int[] arr) {creatHeap(arr); //先建立初堆,现在堆得根结点为最大值for (int i = arr.length - 1; i > 0; --i) {//将最大值放入最后一个位置,并将最后一个元素放到堆顶，然后继续调整堆，不断将次大值放入后面相应的位置//直到 i == 1,元素有序int temp = arr[0];arr[0] = arr[i];arr[i] = temp;heapAdjust(arr, 0, i - 1); //不断调整堆，每次减少最后一个元素位置}}public static void main(String[] args) {int[] arr = new int[] {0,5,9,6,5,8,7,15,2,789,56,145,17,26,0};new HeapSorted().heapSort(arr);for (int temp : arr) {System.out.println(temp);}}
}
4、归并排序
二路归并排序
时间复杂度O{nlog2n}(n为底)
package 排序.归并排序.二路归并排序;public class MSort {/*** 将arr[low~mid]和arr[mid+1~high]合并成一个有序数组**/public static void merge(int[] arr, int low, int mid, int high) {int i = low, j = mid + 1, k = 0;int[] nArr = new int[high - low +1]; //分配一个新的数组，用来作为临时变量,大小为需要归并的数组的元素个数（high-low+1）while (i <= mid && j <= high) { //一个while循环，不断选出两边最小的数放到临时变量中if (arr[i] <= arr[j]) nArr[k++] = arr[i++];else nArr[k++] = arr[j++];}//选出剩下的一端的剩余数据放到临时数组变量尾部，因为不知道那一边先结束，所以设置了两个while循环while (i <= mid) {nArr[k++] = arr[i++];}while (j <= high) {nArr[k++] = arr[j++];}for (int m = low,n = 0; m <= high; m ++, n++) { //使用一个for循环将临时变量数组的值赋给原始数组，位置为方法参数传进的位置arr[m] = nArr[n];}}//进行归并public static void mergeSort(int[] arr ,int low, int high) {if (low == high) return; //递归终止条件int mid = (low + high) / 2;mergeSort(arr,low,mid); //递归归并左部分,（包含mid）mergeSort(arr,mid + 1, high); //递归归并右部分merge(arr,low,mid,high);}public static void main(String[] args) {int[] arr = {5,6,10,7,9,5,6,3,89,54,54,5,2,4,789,566,216,21,4,3446,246};mergeSort(arr,0,arr.length - 1);for (int temp : arr) {System.out.print(temp + " ");}}
}排序算法（Java实现）相关推荐
- 排序算法python实现_合并排序算法– Java，C和Python实现
排序算法python实现 Merge sort is one of the most efficient sorting algorithms. It works on the principle o ...
- 排序算法java版，速度排行：冒泡排序、简单选择排序、直接插入排序、折半插入排序、希尔排序、堆排序、归并排序、快速排序...
先推荐一篇关于排序算法的文章:http://www.cppblog.com/guogangj/archive/2009/11/13/100876.html 本文思路部分来源于上篇文章,但测得的结果似乎 ...
- 九大排序算法Java实现
之前学习数据结构与算法时花了三天时间整理九大排序算法,并采用Java语言来实现,今天第一次写博客,刚好可以把这些东西从总结的文档中拿出来与大家分享一下,同时作为自己以后的备忘录. 1.排序算法时间复杂 ...
- java基础排序_Java排序算法-Java入门|Java基础课程
1. 课程目标排序是任何语言都会使用到的功能之一,然成果排序的算法有很多,对空间的要求及其时间效率也不尽相同. 本文章以Java语言示例,通过对空间要求.时间效率要求,来对比各种排序算法的使用场景 2 ...
- java 快速排序算法简单_排序算法java版，速度排行：冒泡排序、简单选择排序、直接插入排序、折半插入排序、希尔排序、堆排序、归并排序、快速排序......
先推荐一篇关于排序算法的文章:http://www.cppblog.com/guogangj/archive/2009/11/13/100876.html 本文思路部分来源于上篇文章,但测得的结果似乎 ...
- 八大排序算法Java
概述 排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存. 我们这里说说八大排序就是内部排序. 当n较大, ...
- 常用排序算法-----------JAVA实现
#常用排序算法-插入排序,选择排序,交换排序,归并排序,基数排序 ###排序算法可归类为以下几类: 插入排序: 直接插入排序(DirectInsertSort): 二分法排序(BinarySort): ...
- 排序算法 -- Java
排序算法 冒泡排序 选择排序 反转排序 冒泡排序 算法思想:从前往后逐步对比每个相邻元素值,满足条件则交换. 实现细节:双层循环,外层循环是排序轮数-(数组长度-1),内层循环负责对比和交换次数-(数 ...
- 排序算法 Java实现
选择排序 核心思想 选择最小元素,与第一个元素交换位置:剩下的元素中选择最小元素,与当前剩余元素的最前边的元素交换位置. 分析 选择排序的比较次数与序列的初始排序无关,比较次数都是N(N-1)/2. ...
- 排序算法java源代码_排序算法汇总（java实现，附源代码）
整理系统的时候发现了原来写的各种算法的总结,看了一下,大吃一惊,那时候的我还如此用心,具体的算法,有的已经模糊甚至忘记了,看的时候就把内容整理出来,顺便在熟悉一下,以后需要的时候就可以直接过来摘抄了. ...
最新文章
- 计算机在生物科学领域的应用论文,大学生物科学教学中计算机的应用
- CalcBackProject函数
- python如何安装torch_PyTorch安装与基本使用详解
- muduo网络库学习（四）事件驱动循环EventLoop
- $nextTick 源码
- MongoDB 教程一: 安装和使用 (Mongodb启动命令mongod参数说明)
- 网页边框和网页文字阴影
- JS执行Promise
- delphi trichviewedit 设置一行的段落_HTML中的文本与段落（3）
- vs2008 sp1安装时候系统盘空间不够问题，解决方式
- 远程控制teamviewer|远程桌面teamviewer|远程桌面连接软件teamviewer|teamviewer无人值守
- 类似：%u6D59%u6C5F%字符转中文
- 【Nginx 快速入门】反向代理、负载均衡、动静分离
- OpenCV框架与图像插值算法
- 什么是等级保护？等保二级和三级的区别？
- 转载--[数据库] MySQL汉字字段按拼音排序
- csv文件示例_自己动手？ -一个简单的CSV解析器示例
- HTML期末学生大作业-班级校园我的校园网页设计与实现html+css+javascript
- qrcode.js 生成二维码包含logo和背景图片及IE下载二维码
- Java Data truncation:Incorrect xxx value: ‘xxx‘ for column ‘xxx‘ at row 1问题