java 算法 排序算法_Java七种排序算法以及实现
Java常见七种排序算法以及实现
最近学习一些排序算法,怕自己以后忘记就打算整理起来供自己复习
萌新一枚学习Java没多久,以下仅供参考。如有错误希望大佬指正,欢迎大家在评论区交流探讨。
1.冒泡排序
通过待排序的序列从前往后依次比较相邻的元素,若发现逆序则两两交换,直到下一趟排序下来没有进行交换,说明排序完成
冒泡排序每一趟会确定一个最大值(默认从小到大)
import java.util.Arrays;
public class BubbleSort {
public static void main(String[] args) {
int array[] = {10,9,2,-3,6,8,1,-6,-5,4};
for (int i = 0; i < array.length ; i++) { //循环每一趟排序
for (int j = 0; j < array.length-1-i ; j++) {
// 每一趟排序的数据交换
// 由于array[j]是和array[j+1]比较,防止数据越界这里array.length要减一
int temp = 0;
if (array[j]>array[j+1]){
temp = array[j+1];
array[j+1] = array[j];
array[j] = temp;
}
}
}
// 两种方法输出
// 1.格式化输出,需import,之后的代码演示全用格式化输出
System.out.println(Arrays.toString(array));
// 2.for循环输出
for (int i = 0; i < array.length ; i++) {
System.out.print(array[i]+" ");
}
}
}
2.选择排序
第一趟排序是从array[0]到array[array.length-1]找到一个最小值array[n]与array[0]进行交换,第一趟排序是从array[1]到array[array.length-1]找到一个最小值array[n]与array[1]进行交换,直到排序完成
选择排序每一趟排序会确定一个最小值(默认从小到大)
以下是三种不同的代码实现
import java.util.Arrays;
public class SelectSortDemo01 {
public static void main(String[] args) {
int array[] = {10,9,2,-3,6,8,1,-6,-5,4};
for (int i = 0; i < array.length-1 ; i++) {
for (int j = 1+i; j < array.length; j++) {
// 此算法与冒泡排序的算法类似,只不过冒泡算法的每一趟排序是两两比较,这个是第一个数与每一个数比较
int temp = 0;
if (array[i] > array[j]){
temp = array[j];
array[j] = array[i];
array[i] = temp;
}
}
}
System.out.println(Arrays.toString(array));
}
}
import java.util.Arrays;
public class SelectSortDemo02 {
public static void main(String[] args) {
int array[] = {10,9,2,-3,6,8,1,-6,-5,4};
int temp = 0;
for (int j = 0; j
for (int i = 1; (i+j)< array.length ; i++) {
//此算法与上面一个大同小异,也实现了相同的效果,可以根据自己的思维选择一个合适的算法
if (array[j] > array[i+j]) {
temp = array[i+j];
array[i+j] = array[j];
array[j] = temp;
}
}
}
System.out.println(Arrays.toString(array));
}
}
12345678910111213141516171819
public class SelectSortDemo02 {
public static void main(String[] args) {
int array[] = {10,9,2,-3,6,8,1,-6,-5,4};
for (int i = 0; i < array.length-1 ; i++) {
// 与前面两种方法不同的是此算法直接先假定每一趟排序的第i个数的数值最小,提取当前下标i,
// 方便每一趟排序与第i个数据进行交换
// 这样也更容易理解
int min = array[i];
int minIndex = i;
for (int j = 1 + i; j < array.length; j++) {
if (min > array[j] ){
// 说明假定的最小值并不是最小的,需要重置min,此时只需赋值,不需要交换
// 让其循环结束直到赋值到最小值
min = array[j];
minIndex = j;
}
}
// 将最小值放在arr[0],交换
if (minIndex != j) {
array[minIndex] = arr[j];
array[j] = min;
}
}
System.out.println(Arrays.toString(array));
}
}
123456789101112131415161718192021222324252627
3.插入排序
假如有n个数,第一趟排序就是比较前两个数将它们排好(默认从小到大),然后在来一个数比较他们三个再排好
可以理解为斗地主的摸牌,先摸了两张J和K,要把J放在K的前面,在摸一张6要放在J和K的前面,在摸一张10就要放在6和J之间,排摸完了就相当于排序结束
import java.util.Arrays;
public class InsertSortDemo01 {
public static void main(String[] args) {
int[] array = {5, 2, -1, 4, 7};
for (int i = 1; i < array.length; i++) {
// 与选择排序第三种类似,先定义一个待插入的数据和插入的位置,便于之后赋值
int insertVal = array[i];
// 为了将待插入的数插入到array[i]的前一个位置
int insertIndex = i - 1;
// 待插入的位置必须大于等于0,保证数组不越界
while (insertIndex >= 0 && insertVal < array[insertIndex]) {
// 直接赋值不用交换数据
array[insertIndex + 1] = array[insertIndex];
// 为了让第i个数与前面的数都进行比较然后赋值,前面有条件不用但不用担心数组越界
insertIndex--;
}
// insertIndex + 1 = i 说明第i轮已经有序
if (insertIndex + 1 != i) {
array[insertIndex + 1] = insertVal;
}
}
System.out.println(Arrays.toString(array));
}
}
1234567891011121314151617181920212223242526
4.希尔排序
希尔排序相当于对插入排序进行优化,是一种缩小增量排序
希尔排序第一趟按照arraylength\2进行分组,每组分别进行直接插入排序,第二趟按照arraylength\2\2进行分组,每组分别进行直接插入排序,直到增量减至为一,整个文件恰好被分为一组
以下是两种不同的代码实现
import java.util.Arrays;
// 交换法,此实现方法速度是很慢,
// 因为插入排序比较之后直接移位,而此类方法一遇到逆序就会发生交换,
// 交换法与冒泡排序类似,不停的交换效率很低
public class ShellSortDemo02 {
public static void main(String[] args) {
int array[] = {10,9,2,-3,6,8,1,-6,-5,4};
int temp = 0;
for (int len = array.length/2; len > 0;len/=2) {
// 循环每一次分组
for (int i = len; i < array.length; i++) {
// 遍历各组的所有元素,有len组
for (int j = i - len; j >= 0; j -= len) {
if (array[j] > array[j + len]) {
temp = array[j];
array[j] = array[j + len];
array[j + len] = temp;
}
}
}
}
System.out.println(Arrays.toString(array));
}
}
12345678910111213141516171819202122232425
import java.util.Arrays;
public class ShellSortDemo03 {
// 对交换式的希尔排序进行优化,采用移位法
// 当需要插入的数是最小数时,后移的次数明显增多,所以使用分组插入排序会大大的提高效率
public static void main(String[] args) {
int[] array = {10, 9, 2, -3, 6, 8, 1, -6, -5, 4};
// 仍然使用增量len,并逐步缩小增量
for (int len = array.length / 2; len > 0; len /= 2) {
// 逐个对其所在的组进行直接插入排序
for (int i = len; i < array.length; i++) {
int j = i;
int temp = array[j];
if (array[j] < array[j - len]) {
while (j-len >= 0 && temp < array[j - len]) {
// 移动,与直接插入排序不同的是这个是间距len之间的数据移位,而直接插入排序是两两移位
array[j] = array[j - len];
j -=len;
}
// 当退出while循环后,就给temp找到了插入的位置
array[j] = temp;
}
}
}
System.out.println(Arrays.toString(array));
}
}
123456789101112131415161718192021222324252627
快速排序是一种对冒泡排序的改进,第一趟排序以中间的一个数为基准,将数组中比他小的数放在此数的左边,比他大的数放在此数的右边,第二趟排序以第一趟排好的左右的中间一个数为基准,在分别重复上面操作
import java.util.Arrays;
public class QuickSortDemo01 {
public static void main(String[] args) {
int array[] = {10,9,2,-3,6,8,1,-6,-5,4};
quickSort(array,0,array.length-1);
System.out.println(Arrays.toString(array));
}
public static void quickSort(int a[],int l,int r){
if(l>=r)
return;
int i = l; int j = r; int key = a[(l+r)/2];
// 选择第一个数为key,我们数组中间的数为例
while(i
while(i=key)
// 从右向左找第一个小于key的值,找到了,j就前移
j--;
// 如果a[j]
if(i
a[i] = a[j];
i++;
}
while(i
// 从左向右找第一个大于key的值,找到了i就后移
i++;
// 如果a[i]>key值,a[i]会放到后面的a[j]同时j会前移
if(i
a[j] = a[i];
j--;
}
}
//i == j
a[i] = key;
quickSort(a, l, i-1);//递归调用
quickSort(a, i+1, r);//递归调用
}
}
12345678910111213141516171819202122232425262728293031323334353637383940
6.归并排序
归并算法的核心思想就是分解在合并,也就是分治,分解可以采用递归,设一个数组最右边的元素索引为low,最左边的元素的索引为height,中间元素索引为(low+height)/2,每一次分解可以发现当low==height的时候,整个数组被分解成每一个元素,合并就是将两个有序归并段归并为一个有序的归并段,直到有序为止
import java.util.Arrays;
public class MergeSortDemo01 {
//合并函数
public static void merge(int[] array,int low,int mid,int height){
int s1 = low;
int s2 = mid+1;
int[] ret = new int[height-low+1];
int i = 0;//表示ret数组的下标
while (s1<=mid && s2<=height){
if (array[s1]<=array[s2]){
ret[i++] = array[s1++];
}else{
ret[i++] = array[s2++];
}
}
while (s1<=mid){
ret[i++] = array[s1++];
}
while (s2<=height){
ret[i++] = array[s2++];
}
for (int j=0;j
array[low+j] = ret[j];
}
}
public static void mergeSort(int[]array,int low,int height){
if (low>=height){
return;
}
int mid = (low+height)/2;
mergeSort(array,low,mid);//递归分解左半部分
mergeSort(array,mid+1,height);//递归分解右半部本
merge(array,low,mid,height);//合并操作
}
public static void main(String[] args) {
int array[] = {10,9,2,-3,6,8,1,-6,-5,4};
System.out.println(Arrays.toString(array));
mergeSort(array,0,array.length-1);
System.out.println(Arrays.toString(array));
}
}
1234567891011121314151617181920212223242526272829303132333435363738394041424344
7.基数排序
本质上是将整数按位数切割成不同的数字,然后按每个位数分别比较,基数排序又叫桶子法
定义10个编号为0~9一维数组,找到每个数的个位数分别放在对应编号的数组中,然后再将十位数取出分别放在对应编号的数组中,直到取到最高位就变为有序
基数排序是效率最高的稳定性排序法
import java.util.Arrays;
public class RadixSortDemo01 {
public static void main(String[] args) {
int array[] = {10, 99, 2, 457, 6, 83, 16, 96, 25, 48};
radixSort(array);
}
//基数排序算法
public static void radixSort(int[] arr) {
int max = arr[0];
// 假设第一个数是最大数
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
int maxLength = (max + " ").length();
// 定义一个二维数组,表示10个桶,每一个桶是一个一维数组用于存放数据
// 为了防止放入数的时候,数据溢出,则每个一维数组的大小定位arr.length
int[][] bucket = new int[10][arr.length];
// 为了记录每个桶中,实际存放了多少数据,我们定义一个一维数组,我们定义一个一维数组记录各个桶每次放入的数据个数
int[] bucketCounts = new int[10];
for (int k=0,n=1;k
for (int i = 0; i < arr.length; i++) {
// 取出每个元素的个位
int digitOfElement = arr[i] / n % 10;
// 放入到对应的桶中
bucket[digitOfElement][bucketCounts[digitOfElement]] = arr[i];
// 每放一个数据此桶的中的数据就要加一
bucketCounts[digitOfElement]++;
}
// 按照这个桶的顺序(一维数组的下标依次取出数据,放入原来数组)
int index = 0;
// 遍历每一个桶并将桶中数据放入原数组
for (int i = 0; i < bucketCounts.length; i++) {
// 如果桶中有数据我们才放入到原数组
if (bucketCounts[i] != 0) {
for (int j = 0; j < bucketCounts[i]; j++) {
// 取出元素放入到arr
arr[index++] = bucket[i][j];
}
}
// 第轮处理后需要将每一个bucketCounts[i] = 0;
bucketCounts[i] = 0;
}
System.out.println("第"+(k+1)+"轮排序 arr =" + Arrays.toString(arr));
}
}
}
java 算法 排序算法_Java七种排序算法以及实现相关推荐
- 七种排序算法(C++)
排序算法 引言 冒泡排序 简单选择排序 直接插入排序 希尔排序 堆排序 归并排序 快速排序 引言 排序中主要包含数据元素的比较和交换,本文以C++实现以下七种排序算法,以从小到大排序为例. 如有错误, ...
- 常用七种排序之冒泡排序(排序图解+分析Java
hello呀!各位,这里是Sunlightʊə. 目前大三,主要在学习Java语言.可以一起交流呀! 相关文章: 常用七种排序之选择排序(排序图解+分析Java 常用七种排序之希尔排序(排序图解+分析 ...
- AcWing进阶算法课Level-4 第七章 基础算法
AcWing进阶算法课Level-4 第七章 基础算法 启发式合并 AcWing 2154. 梦幻布丁73人打卡 AcWing 3189. Lomsat gelral54人打卡 manacher算法 ...
- Java设计模式之单例模式(七种写法)
Java设计模式之单例模式(七种写法) 第一种,懒汉式,lazy初始化,线程不安全,多线程中无法工作: public class Singleton {private static Singleton ...
- 数据结构(三) 用java实现七种排序算法。
很多时候,听别人在讨论快速排序,选择排序,冒泡排序等,都觉得很牛逼,心想,卧槽,排序也分那么多种,就觉得别人很牛逼呀,其实不然,当我们自己去了解学习后发现,并没有想象中那么难,今天就一起总结一下各种排 ...
- 排序入门的七种算法(冒泡—插入—希尔—堆—选择—归并—快速)
---------文中的部分代码思路参考自<大话数据结构>一书. 目录 冒泡排序 插入排序 希尔排序 堆排序 选择排序 归并排序 快速排序 冒泡排序 原始的冒泡排序是对整个序列相邻两数字间 ...
- 常见七种排序算法对比(超全!!!)
文章目录 一, 直接插入排序 二,希尔排序 三.选择排序 四,堆排序 五,冒泡排序 六,快速排序 如何优化快排呢? 三数取中法优化快排 七,归并排序 怎么判断是不是稳定的排序呢? 如果当前这个序列,在 ...
- Python实现经典七种排序算法
#2018-06-02 June Saturday the 22 week, the 153 day SZ #数组排序算法大全用Python3实现 #参考https://www.cnblogs.com ...
- python几种排序_Python实现几种排序算法
Python实现几种排序算法 2018年11月12日 09:39 1.二分查找 import random def binary_search(li,target): start = 0 end = ...
最新文章
- 【某小学生作文】《我的爸爸是名驾驶员》
- 支付宝支付 第七集:产品数据接口的定义和测试
- Windows 下 修改 Anaconda3 jupyter 默认启动目录
- ASP.NET Core之跨平台的实时性能监控(2.健康检查)
- fpga与三八译码器(BASYS3 VIVADO18)
- matlab程序复制出现乱码,matlab程序复制到Word文档里变成乱码,该如何改?
- python 矩阵连乘
- JSONP 跨域原理
- 阿里巴巴开源项目汇总-(前端)
- 海马玩模拟器启动失败,start machine failed! error code = 3和error code=21
- ECCVW 2022 | 第二届城市规模点云语义理解挑战赛
- Win8.1 安装nltk及nltk_data数据
- C语言中四种取整方式、取余/取模的运算以及负数取模的问题
- 欧几里得算法及扩展欧几里得
- 我的开源项目,趣享GIF源代码已正式公开
- Java中length、length()、size()区别
- matlab 爱,matlab
- 迅为-i.MX6ULL开发板-QT实战项目DHT11网络编程实战练习(一)
- DNS服务器配置和测试
- 韩国烧脑片力荐,错过一眼都可能会是遗憾
热门文章
- python序列化详细教程
- python 将字节字符串转换成十六进制字符串
- Python实现im2col和col2im函数
- python基础教程:while循环与运算符和编码
- 用python实现图书管理系统
- Java中测长函数_Core Java测试题
- M 点滑动平均 Python 实现
- docker查询占用端口号服务命令
- 从左边列表复制到右边列表html,JQ实现左侧列表内容移动至右侧列表出现的问题...
- matlab处理abaqus_Abaqus/用Abaqus进行参数分析(python+maltab助攻)