Java 内部排序法总结与源码

最新推荐文章于 2024-04-20 02:52:27 发布
最新推荐文章于 2024-04-20 02:52:27 发布
阅读量150 收藏 1
点赞数 1
分类专栏： 排序 文章标签： 内部排序法总结与源码 Java排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/clinke/article/details/99685105
版权

Java 内部排序法 总结 与 源码

总结

在这里插入图片描述

1.1 冒泡排序

代码片.

public class Sort {
	public static void bubbleSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int e = arr.length - 1; e > 0; e--) {
			for (int i = 0; i < e; i++) {
				if (arr[i] > arr[i + 1]) {
					swap(arr, i, i + 1);
				}
			}
		}
	}
	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

	public static void Print(String s,int []arr) 
	{
		System.out.print(s+" : ");
		for(int i=0;i<arr.length;i++)
			System.out.print(arr[i]+" ");
		System.out.println();
	}
	public static void main(String[] args) 
	{
		int[]  arr= {9,5,6,7,1,3,2,4};
		Print( "排序前",arr) ;
		bubbleSort( arr);
		Print( "排序后",arr) ;
	}
}

输出.

	排序前 : 9 5 6 7 1 3 2 4 
	排序后 : 1 2 3 4 5 6 7 9

1.2 选择排序

代码片.

public class Sort {
	public static void selectionSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 0; i < arr.length - 1; i++) {
			int minIndex = i;
			for (int j = i + 1; j < arr.length; j++) {
				minIndex = arr[j] < arr[minIndex] ? j : minIndex;
			}
			swap(arr, i, minIndex);
		}
	}
	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

	public static void Print(String s,int []arr) 
	{
		System.out.print(s+" : ");
		for(int i=0;i<arr.length;i++)
			System.out.print(arr[i]+" ");
		System.out.println();
	}
	public static void main(String[] args) 
	{
		int[]  arr= {9,5,6,7,1,3,2,4};
		Print( "排序前",arr) ;
		selectionSort( arr);
		Print( "排序后",arr) ;
	}
}

输出.

	排序前 : 9 5 6 7 1 3 2 4 
	排序后 : 1 2 3 4 5 6 7 9

1.3 插入排序

代码片.

public class Sort {
	public static void insertionSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 1; i < arr.length; i++) {
			for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
				swap(arr, j, j + 1);
			}
		}
	}
	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

	public static void Print(String s,int []arr) 
	{
		System.out.print(s+" : ");
		for(int i=0;i<arr.length;i++)
			System.out.print(arr[i]+" ");
		System.out.println();
	}
	public static void main(String[] args) 
	{
		int[]  arr= {9,5,6,7,1,3,2,4};
		Print( "排序前",arr) ;
		insertionSort( arr);
		Print( "排序后",arr) ;
	}
}

输出.

	排序前 : 9 5 6 7 1 3 2 4 
	排序后 : 1 2 3 4 5 6 7 9

1.4 希尔排序

代码片.

public class Sort {
	public static void shellSort(int[] arr){
		if (arr == null || arr.length < 2) {
			return;
		}	 
	    int inserIndex = 0;
	    int gap = arr.length/2;
	    while (gap>0)
	    {
	        for (int i = gap; i < arr.length; i++) {
	            inserIndex =i;
	            int temp = arr[i];
	            while (inserIndex>=gap && arr[inserIndex-gap]>temp){
	                arr[inserIndex] = arr[inserIndex-gap];
	                inserIndex-=gap;
	            }
	            arr[inserIndex]=temp;
	        }
	        gap = gap/2;
	    }	   
	}
	
	public static void Print(String s,int []arr) 
	{
		System.out.print(s+" : ");
		for(int i=0;i<arr.length;i++)
			System.out.print(arr[i]+" ");
		System.out.println();
	}
	public static void main(String[] args) 
	{
		int[]  arr= {9,5,6,7,1,3,2,4};
		Print( "排序前",arr) ;
		shellSort( arr);
		Print( "排序后",arr) ;
	}
}

输出.

	排序前 : 9 5 6 7 1 3 2 4 
	排序后 : 1 2 3 4 5 6 7 9

2.1 快速排序

代码片.

public class Sort {
	public static void quickSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		quickSort(arr, 0, arr.length - 1);
	}

	public static void quickSort(int[] arr, int l, int r) {
		if (l < r) {
			swap(arr, l + (int) (Math.random() * (r - l + 1)), r);
			int[] p = partition(arr, l, r);
			quickSort(arr, l, p[0] - 1);
			quickSort(arr, p[1] + 1, r);
		}
	}

	public static int[] partition(int[] arr, int l, int r) {
		int less = l - 1;
		int more = r;
		while (l < more) {
			if (arr[l] < arr[r]) {
				swap(arr, ++less, l++);
			} else if (arr[l] > arr[r]) {
				swap(arr, --more, l);
			} else {
				l++;
			}
		}
		swap(arr, more, r);
		return new int[] { less + 1, more };
	}
	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

	public static void Print(String s,int []arr) 
	{
		System.out.print(s+" : ");
		for(int i=0;i<arr.length;i++)
			System.out.print(arr[i]+" ");
		System.out.println();
	}
	public static void main(String[] args) 
	{
		int[]  arr= {9,5,6,7,1,3,2,4};
		Print( "排序前",arr) ;
		quickSort( arr);
		Print( "排序后",arr) ;
	}
}

输出.

	排序前 : 9 5 6 7 1 3 2 4 
	排序后 : 1 2 3 4 5 6 7 9

2.2 堆积排序

代码片.

public class Sort {
	public static void heapSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			heapInsert(arr, i);
		}
		int size = arr.length;
		swap(arr, 0, --size);
		while (size > 0) {
			heapify(arr, 0, size);
			swap(arr, 0, --size);
		}
	}

	public static void heapInsert(int[] arr, int index) {
		while (arr[index] > arr[(index - 1) / 2]) {
			swap(arr, index, (index - 1) / 2);
			index = (index - 1) / 2;
		}
	}

	public static void heapify(int[] arr, int index, int size) {
		int left = index * 2 + 1;
		while (left < size) {
			int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
			largest = arr[largest] > arr[index] ? largest : index;
			if (largest == index) {
				break;
			}
			swap(arr, largest, index);
			index = largest;
			left = index * 2 + 1;
		}
	}
	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

	public static void Print(String s,int []arr) 
	{
		System.out.print(s+" : ");
		for(int i=0;i<arr.length;i++)
			System.out.print(arr[i]+" ");
		System.out.println();
	}
	public static void main(String[] args) 
	{
		int[]  arr= {9,5,6,7,1,3,2,4};
		Print( "排序前",arr) ;
		heapSort( arr);
		Print( "排序后",arr) ;
	}
}

输出.

	排序前 : 9 5 6 7 1 3 2 4 
	排序后 : 1 2 3 4 5 6 7 9

2.3 基数排序

代码片.

public class Sort {
	public static void radixSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		radixSort(arr, 0, arr.length - 1, maxbits(arr));
	}

	public static int maxbits(int[] arr) {
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < arr.length; i++) {
			max = Math.max(max, arr[i]);
		}
		int res = 0;
		while (max != 0) {
			res++;
			max /= 10;
		}
		return res;
	}

	public static void radixSort(int[] arr, int begin, int end, int digit) {
		final int radix = 10;
		int i = 0, j = 0;
		int[] count = new int[radix];
		int[] bucket = new int[end - begin + 1];
		for (int d = 1; d <= digit; d++) {
			for (i = 0; i < radix; i++) {
				count[i] = 0;
			}
			for (i = begin; i <= end; i++) {
				j = getDigit(arr[i], d);
				count[j]++;
			}
			for (i = 1; i < radix; i++) {
				count[i] = count[i] + count[i - 1];
			}
			for (i = end; i >= begin; i--) {
				j = getDigit(arr[i], d);
				bucket[count[j] - 1] = arr[i];
				count[j]--;
			}
			for (i = begin, j = 0; i <= end; i++, j++) {
				arr[i] = bucket[j];
			}
		}
	}

	public static int getDigit(int x, int d) {
		return ((x / ((int) Math.pow(10, d - 1))) % 10);
	}
	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

	public static void Print(String s,int []arr) 
	{
		System.out.print(s+" : ");
		for(int i=0;i<arr.length;i++)
			System.out.print(arr[i]+" ");
		System.out.println();
	}
	public static void main(String[] args) 
	{
		int[]  arr= {9,5,6,7,1,3,2,4};
		Print( "排序前",arr) ;
		radixSort( arr);
		Print( "排序后",arr) ;
	}
}

输出.

	排序前 : 9 5 6 7 1 3 2 4 
	排序后 : 1 2 3 4 5 6 7 9
clinke
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java源码之Arrays内部排序实现（timsort的实现）
lkj41110的博客
03-05 7448
在Arrays工作类里有sort()方法可以用来排序，jdk对所有基本类型设置设置了不同入参sort方法进行支持。 从源码上看，基本类型的排序都是使用了了DualPivotQuicksort的排序方法(我看的是jdk8，)。DualPivotQuicksort是快排的一种优化，具体在这里不展开了。 当参数类型为对象数组时，在原来的版本使用的归并排序（以后将会删除 ），现在使用的timSor...
Java常见排序算法源码集.rar
07-10
这个名为"Java常见排序算法源码集.rar"的压缩文件显然包含了多种常用的排序算法的Java实现，对于初学者来说，这是一个非常宝贵的资源，可以深入理解各种算法的工作原理。 首先，我们来逐一探讨这些常见的排序算法：...
Java十种经典排序算法详解与应用
weixin_69595694的博客
01-06 1281
Java中提供了多种排序算法实现，涵盖了简单排序和高级排序技术。这些算法包括但不限于冒泡排序（Bubble Sort）、选择排序（Selection Sort）、插入排序（Insertion Sort）、希尔排序（Shell Sort）、归并排序（Merge Sort）、快速排序（Quick Sort）、堆排序（Heap Sort）、计数排序（Counting Sort）、桶排序（Bucket Sort）以及基数排序（Radix Sort）。每种排序算法在时间复杂度、空间复杂度、稳定性等方面各有优劣。
Java知识体系最强总结(2021版)
热门推荐
ThinkWon的博客
12-18 110万+
更新于2019-12-15 10:38:00 本人从事Java开发已多年，平时有记录问题解决方案和总结知识点的习惯，整理了一些有关Java的知识体系，这不是最终版，会不定期的更新。也算是记录自己在从事编程工作的成长足迹，通过博客可以促进博主与阅读者的共同进步，结交更多志同道合的朋友。特此分享给大家，本人见识有限，写的博客难免有错误或者疏忽的地方，还望各位大佬指点，在此表示感激不尽。 文章目录...
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 24万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
七, Java实现八大排序算法, 带源码详解
菜菜的大数据开发の路
03-09 2458
八大排序算法带源码详解 概要： 内部排序：待排序记录存放在计算机内存中进行的排序过程。通过比较次数（时间复杂度）来衡量效率； 外部排序：待排序记录的数量很大，以致于内存不能一次容纳全部记录，所以在排序过程中需要对外存进行访问的排序过程。通过IO次数（即读写外存的次数）来衡量效率。 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时
Java基础知识总结（2021版）
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
java字符串排序算法_聊聊 Java String 源码的排序算法
weixin_28907839的博客
02-18 492
文章工程：JDK 1.8工程名：algorithm-core-learning # StringComparisonDemo工程地址：https://github.com/JeffLi1993/algorithm-core-learning前言Q：什么是选择问题？选择问题，是假设一组 N 个数，要确定其中第 K 个最大值者。比如 A 与 B 对象需要哪个更大？又比如：要考虑从一些数组中找出最大项？...
11 种 内部排序算法 大PK（Java 语言实现），究竟谁最快？
愿你饱经冷暖，仍保纯真
10-07 3091
11 种内部排序算法
java 冒泡排序
weixin_45428254的博客
06-06 5943
这段代码实现了一个简单的冒泡排序算法，它接受一个整数数组作为参数。在函数内部，我们使用两个嵌套的循环来遍历数组并比较相邻的元素。如果它们顺序不正确，我们就交换它们的位置。最终，数组中的元素将按升序排列。Java 冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来，直到没有再需要交换的元素。
【算法】常见排序算法总结
2401_84408418的博客
04-20 936
针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。下面的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）最新整理电子书《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！较t[mg]要大得多。因此，提高外排的效率应主要着眼于减少外存信息读写的次数d。
《数据结构与算法：Java语言描述》源码.zip
01-14
排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法，分支限界...
Java对象排序、中文排序、SortedSet排序使用和源码讲解
12-22
`Collections.sort()`和`Arrays.sort()`的底层实现通常使用了高效的排序算法，如快速排序、归并排序等。这些算法在JDK的源码中实现，但具体的实现细节可能会因版本的不同而有所变化。`TreeSet`内部使用红黑树数据...
java算法大全源码压缩包.zip
03-26
快速排序是一种高效的排序算法，由C.A.R. Hoare于1960年提出。它的基本思想是选取一个“基准”元素，然后将数组分为两部分，一部分的所有元素都比基准小，另一部分的所有元素都比基准大，再对这两部分分别进行快速...
Java数据结构和算法系列文章，源码.zip
01-14
排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法，分支限界...
SAP R3安装文档 .doc
07-11
SAP R3安装文档
T100快捷键.pdf
最新发布
07-11
T100快捷键
创意动漫主题招新PPT模板
07-11
【作品名称】：创意动漫主题招新PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：创意动漫主题招新PPT模板
项目招商计划书PPT模板
07-11
【作品名称】：项目招商计划书PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
Java实现常见排序算法总结
05-02
Java实现常见排序算法总结：本文主要对常见的排序算法进行分析和实现。其中，插入排序是一种常见排序算法，其中包括直接插入排序。直接插入排序的思想是想象打牌，摸第一张牌时，它是有序的。接着摸牌时，都要与已经...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值