Java排序算法集合

Java集合框架:高级特性与算法之集合排序算法(13) List<String> cities = Arrays.asList("北京", "上海", "广州"); 阅读详情

网罗了主流的排序算法,冒泡,选择,快速排序等

package test;

import java.util.Random;

/**
 * 
 * 排序算法类
 * 
 * 
 * 排序算法的分类如下:
 * 
 * 1.插入排序(直接插入排序、折半插入排序、希尔排序);
 * 
 * 2.交换排序(冒泡泡排序、快速排序);
 * 
 * 3.选择排序(直接选择排序、堆排序);
 * 
 * 4.归并排序;
 * 
 * 5.基数排序。
 * 
 * 
 * 
 * 关于排序方法的选择:
 * 
 * (1)若n较小(如n≤50),可采用直接插入或直接选择排序。
 * 
 *  当记录规模较小时,直接插入排序较好;否则因为直接选择移动的记录数少于直接插人,应选直接选择排序为宜。
 * 
 * (2)若文件初始状态基本有序(指正序),则应选用直接插人、冒泡或随机的快速排序为宜;
 * 
 * (3)若n较大,则应采用时间复杂度为O(nlgn)的排序方法:快速排序、堆排序或归并排序。
 * 
 * 
 */

public class SortAlgorithm {

	/**
	 * 初始化测试数组的方法
	 * @return 一个初始化好的数组
	 */
	public int[] createArray() {
		Random random = new Random();
		int[] array = new int[10];

		for (int i = 0; i < 10; i++) {
			array[i] = random.nextInt(100) - random.nextInt(100);// 生成两个随机数相减,保证生成的数中有负数
		}

		System.out.println("==========原始序列==========");
		printArray(array);

		return array;

	}

	/**
	 * 打印数组中的元素到控制台
	 * @param source
	 */
	private void printArray(int[] data) {
		for (int i : data) {
			System.out.print(i + " ");
		}
		
		System.out.println();
	}

	/**
	 * 交换数组中指定的两元素的位置
	 * @param data
	 * @param x
	 * @param y
	 */
	private void swap(int[] data, int x, int y) {

		int temp = data[x];
		data[x] = data[y];
		data[y] = temp;
	}

	/**
	 * 冒泡排序----交换排序的一种
	 * 方法:相邻两元素进行比较,如有需要则进行交换,每完成一次循环就将最大元素排在最后(如从小到大排序),下一次循环是将其他的数进行类似操作。
	 * 性能:	比较次数O(n^2),n^2/2;
	 *      交换次数O(n^2),n^2/4
	 * 
	 * @param data 要排序的数组
	 * @param sortType 排序类型
	 * @return
	 */
	public void bubbleSort(int[] data, String sortType) {
		if (sortType.equals("asc")) { // 正排序,从小排到大
			// 比较的轮数
			for (int i = 1; i < data.length; i++) {
				// 将相邻两个数进行比较,较大的数往后冒泡
				for (int j = 0; j < data.length - i; j++) {
					if (data[j] > data[j + 1]) {
						// 交换相邻两个数
						swap(data, j, j + 1);
					}
				}
			}
		} else if (sortType.equals("desc")) { // 倒排序,从大排到小
			// 比较的轮数
			for (int i = 1; i < data.length; i++) {
				// 将相邻两个数进行比较,较大的数往后冒泡
				for (int j = 0; j < data.length - i; j++) {
					if (data[j] < data[j + 1]) {
						// 交换相邻两个数
						swap(data, j, j + 1);
					}
				}
			}
		} else {
			System.out.println("您输入的排序类型错误!");
		}

		printArray(data);// 输出冒泡排序后的数组值

	}

	/**
	 * 
	 * 直接选择排序法----选择排序的一种
	 * 
	 * 方法:每一趟从待排序的数据元素中选出最小(或最大)的一个元素, 顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。
	 * 
	 * 性能:比较次数O(n^2),n^2/2
	 *      交换次数O(n),n
	 * 
	 * 交换次数比冒泡排序少多了,由于交换所需CPU时间比比较所需的CUP时间多,所以选择排序比冒泡排序快。
	 * 
	 * 但是N比较大时,比较所需的CPU时间占主要地位,所以这时的性能和冒泡排序差不太多,但毫无疑问肯定要快些。
	 * 
	 * @param data 要排序的数组
	 * @param sortType 排序类型
	 * @return
	 */
	public void selectSort(int[] data, String sortType) {
		if (sortType.equals("asc")) { // 正排序,从小排到大
			int index;
			for (int i = 1; i < data.length; i++) {
				index = 0;
				for (int j = 1; j <= data.length - i; j++) {
					if (data[j] > data[index]) {
						index = j;
					}
				}
				// 交换在位置data.length-i和index(最大值)两个数
				swap(data, data.length - i, index);
			}
		} else if (sortType.equals("desc")) { // 倒排序,从大排到小
			int index;
			for (int i = 1; i < data.length; i++) {
				index = 0;
				for (int j = 1; j <= data.length - i; j++) {
					if (data[j] < data[index]) {
						index = j;
					}
				}
				// 交换在位置data.length-i和index(最大值)两个数
				swap(data, data.length - i, index);
			}
		} else {
			System.out.println("您输入的排序类型错误!");
		}

		printArray(data);// 输出直接选择排序后的数组值
	}

	/**
	 * 
	 * 插入排序
	 * 
	 * 方法:将一个记录插入到已排好序的有序表(有可能是空表)中,从而得到一个新的记录数增1的有序表。
	 * 
	 * 性能:比较次数O(n^2),n^2/4
	 *      复制次数O(n),n^2/4
	 * 
	 * 比较次数是前两者的一般,而复制所需的CPU时间较交换少,所以性能上比冒泡排序提高一倍多,而比选择排序也要快。
	 * 
	 * @param data 要排序的数组
	 * 
	 * @param sortType 排序类型
	 */
	public void insertSort(int[] data, String sortType) {
		if (sortType.equals("asc")) { // 正排序,从小排到大
			// 比较的轮数
			for (int i = 1; i < data.length; i++) {
				// 保证前i+1个数排好序
				for (int j = 0; j < i; j++) {
					if (data[j] > data[i]) {
						// 交换在位置j和i两个数
						swap(data, i, j);
					}
				}
			}
		} else if (sortType.equals("desc")) { // 倒排序,从大排到小
			// 比较的轮数
			for (int i = 1; i < data.length; i++) {
				// 保证前i+1个数排好序
				for (int j = 0; j < i; j++) {
					if (data[j] < data[i]) {
						// 交换在位置j和i两个数
						swap(data, i, j);
					}
				}
			}
		} else {
			System.out.println("您输入的排序类型错误!");
		}

		printArray(data);// 输出插入排序后的数组值
	}

	/**
	 * 反转数组的方法
	 * 
	 * @param data 源数组
	 */
	public void reverse(int[] data) {
		int length = data.length;
		int temp = 0;// 临时变量

		for (int i = 0; i < length / 2; i++) {
			temp = data[i];
			data[i] = data[length - 1 - i];
			data[length - 1 - i] = temp;
		}

		printArray(data);// 输出到转后数组的值
	}

	/**
	 * 快速排序
	 * 
	 * 快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists)。
	 * 
	 * 步骤为:
	 * 
	 * 1. 从数列中挑出一个元素,称为 "基准"(pivot),
	 * 
	 * 2. 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分割之后,
	 * 该基准是它的最后位置。这个称为分割(partition)操作。
	 * 
	 * 3. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。
	 * 
	 * 递回的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递回下去,但是这个算法总会结束,因为在每次的迭代(iteration)
	 * 中,它至少会把一个元素摆到它最后的位置去。
	 * 
	 * @param data 待排序的数组
	 * @param low
	 * @param high
	 * 
	 * @see SortTest#qsort(int[], int, int)
	 * 
	 * @see SortTest#qsort_desc(int[], int, int)
	 */
	public void quickSort(int[] data, String sortType) {
		if (sortType.equals("asc")) { // 正排序,从小排到大
			qsort_asc(data, 0, data.length - 1);
		} else if (sortType.equals("desc")) { // 倒排序,从大排到小
			qsort_desc(data, 0, data.length - 1);
		} else {
			System.out.println("您输入的排序类型错误!");
		}
	}

	/**
	 * 快速排序的具体实现,排正序
	 * 
	 * @param data
	 * @param low
	 * @param high
	 */
	private void qsort_asc(int data[], int low, int high) {
		int i, j, x;
		if (low < high) { // 这个条件用来结束递归
			i = low;
			j = high;
			x = data[i];

			while (i < j) {
				while (i < j && data[j] > x) {
					j--; // 从右向左找第一个小于x的数
				}
				if (i < j) {
					data[i] = data[j];
					i++;
				}
				while (i < j && data[i] < x) {
					i++; // 从左向右找第一个大于x的数
				}
				if (i < j) {
					data[j] = data[i];
					j--;
				}
			}

			data[i] = x;
			qsort_asc(data, low, i - 1);
			qsort_asc(data, i + 1, high);
		}
	}

	/**
	 * 
	 * 快速排序的具体实现,排倒序
	 * 
	 * @param data
	 * @param low
	 * @param high
	 */
	private void qsort_desc(int data[], int low, int high) {
		int i, j, x;
		if (low < high) { // 这个条件用来结束递归
			i = low;
			j = high;
			x = data[i];

			while (i < j) {
				while (i < j && data[j] < x) {
					j--; // 从右向左找第一个小于x的数
				}
				if (i < j) {
					data[i] = data[j];
					i++;
				}
				while (i < j && data[i] > x) {
					i++; // 从左向右找第一个大于x的数
				}
				if (i < j) {
					data[j] = data[i];
					j--;
				}
			}

			data[i] = x;
			qsort_desc(data, low, i - 1);
			qsort_desc(data, i + 1, high);
		}
	}

	/**
	 * 
	 * 二分查找特定整数在整型数组中的位置(递归)
	 * 
	 * 查找线性表必须是有序列表
	 * 
	 * @paramdataset
	 * @paramdata
	 * @parambeginIndex
	 * @paramendIndex
	 * @returnindex
	 */
	public int binarySearch(int[] dataset, int data, int beginIndex, int endIndex) {

		int midIndex = (beginIndex + endIndex) >>> 1; // 相当于mid = (low + high) / 2,但是效率会高些

		if (data < dataset[beginIndex] || data > dataset[endIndex] || beginIndex > endIndex) {
			return -1;
		}

		if (data < dataset[midIndex]) {
			return binarySearch(dataset, data, beginIndex, midIndex - 1);
		} else if (data > dataset[midIndex]) {
			return binarySearch(dataset, data, midIndex + 1, endIndex);
		} else {
			return midIndex;
		}

	}

	/**
	 * 
	 * 二分查找特定整数在整型数组中的位置(非递归)
	 * 
	 * 查找线性表必须是有序列表
	 * 
	 * @paramdataset
	 * @paramdata
	 * @returnindex
	 */
	public int binarySearch(int[] dataset, int data) {
		int beginIndex = 0;
		int endIndex = dataset.length - 1;
		int midIndex = -1;

		if (data < dataset[beginIndex] || data > dataset[endIndex] || beginIndex > endIndex) {
			return -1;
		}

		while (beginIndex <= endIndex) {
			midIndex = (beginIndex + endIndex) >>> 1; // 相当于midIndex =(beginIndex + endIndex) / 2,但是效率会高些

			if (data < dataset[midIndex]) {
				endIndex = midIndex - 1;
			} else if (data > dataset[midIndex]) {
				beginIndex = midIndex + 1;
			} else {
				return midIndex;
			}
		}

		return -1;
	}

	public static void main(String[] args) {

		SortAlgorithm sortTest = new SortAlgorithm();

		int[] array = sortTest.createArray();
		System.out.println("==========冒泡排序后(正序)==========");

		sortTest.bubbleSort(array, "asc");
		System.out.println("==========冒泡排序后(倒序)==========");

		sortTest.bubbleSort(array, "desc");
		array = sortTest.createArray();
		System.out.println("==========倒转数组后==========");

		sortTest.reverse(array);
		array = sortTest.createArray();
		System.out.println("==========选择排序后(正序)==========");

		sortTest.selectSort(array, "asc");
		System.out.println("==========选择排序后(倒序)==========");

		sortTest.selectSort(array, "desc");
		array = sortTest.createArray();
		System.out.println("==========插入排序后(正序)==========");

		sortTest.insertSort(array, "asc");
		System.out.println("==========插入排序后(倒序)==========");

		sortTest.insertSort(array, "desc");
		array = sortTest.createArray();
		System.out.println("==========快速排序后(正序)==========");

		sortTest.quickSort(array, "asc");
		sortTest.printArray(array);
		System.out.println("==========快速排序后(倒序)==========");

		sortTest.quickSort(array, "desc");
		sortTest.printArray(array);
		System.out.println("==========数组二分查找==========");

		System.out.println("您要找的数在第" + sortTest.binarySearch(array, 74) + "个位子。(下标从0计算)");
	}
}



Java排序算法集合工具类 在Java编程中,排序算法是非常常见且重要的工具。它们用于对数据进行排序,以便更方便地进行搜索、查找和分析。本文将介绍一个Java排序算法集合工具类,其中包含多种常见的排序算法实现。以上是几种常见的排序算法的Java实现。你可以根据需要选择合适的排序算法来对你的数据进行排序。这些排序算法在不同的场景下具有不同的优劣势,因此需要根据具体情况选择适当的算法。使用这些排序算法集合工具类,你可以方便地对数组进行排序。希望这个排序算法集合工具类能够帮助你在Java编程中轻松地进行排序操作! 阅读详情

相关推荐

各种排序算法合集

各种排序算法合集,每种排序算法都继承自一个基类,各种具体的算法各自实现

必须知道的八大种排序算法【java实现】(一) 冒泡排序、快速排序

冒泡排序   冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。   冒泡排序的示例: 冒泡排序的算法实现如下:【排序后,数组从小到大排列】    /** * 冒泡排

编故事的逗老师的专栏 581

35种基于比较的内部排序算法的动态图示分析和演示

35种基于比较的内部排序算法的动态图示分析和演示

Java笔记6.1

计算 冒泡排序(Bubble Sort) 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 算法描述 比较相邻的元素。如果第一个比第二个大,就交换它们两个; 对每一对相邻元素作同样...

qq_45728278的博客 243

排序算法demo

包含冒泡排序,快速排序,以及java封装的Collections.sort排序方式,原文链接http://blog.youkuaiyun.com/u014544193/article/details/51162654

JAVA排序算法集合

1.插入排序(直接插入排序、折半插入排序、希尔排序); 2.交换排序(冒泡泡排序、快速排序); 3.选择排序(直接选择排序、堆排序); 4.归并排序; 5.基数排序

Android开发 常用排序算法

1、冒泡排序 冒泡排序,数组从小到大排列,比较相邻的元素。如果第一个比第二个大,就交换他们两个。 示例: /* * 冒泡排序 * 前后两个元素相比较,最大的往后排,每一轮都可以找到一个最大的元素 */ publicstaticint[] bubbleSort(int[] nums){ int temp =0;

SunshineBoy的博客 2581

各种排序算法小结

各种排序算法小结 各种排序算法小结 各种排序算法小结 真的不错

Android 7大常用算法

堆排序算法、本质就是先构造一个大顶堆,parent比children大,root节点就是最大的节点 把最大的节点(root)与尾节点(最后一个节点,比较小)位置互换,剩下最后的尾节点,现在最大,其余的,从第一个元素开始到尾节点前一位,构造大顶堆递归。

yihanss的博客 988

在摩尔线程 MTT S80 上使用 Ollama 进行 DeepSeek R1 蒸馏版模型推理

本文主要介绍了如何在摩尔线程 MTT S80 上通过 Ollama 快速完成DeepSeek R1 蒸馏系列模型的推理。

摩尔线程blog中心 3606

【知识点总结】电路原理 第一讲

大家好,从今天起,我将开始更新自上大学以来所学到的各种知识,之所以选择更新它们是因为最近我一直在收拾整理自己自上大学以来所收获到的各种知识,看着那厚厚一沓的书本心里不由得犯愁。如果我想找到特定的知识,那岂不是得翻到猴年马月。俗话说得好,下雨天打鞋子,闲着也是闲着,为此我设置一个专栏,将知识点一一分类总结,目的在于更好的整理所学的知识。本人学艺不精,有一些知识点地方可能存在瑕疵,希望各位大佬可以多多指教。以下是本篇文章正文内容虚断:一般通用性运算放大器的正反向输入端之间的电阻非常非常的大。

weixin_51130221的博客 4万+

android中常用5种排序算法

在android中会经常使用一些算法来实现一些复杂的逻辑; 在这片博文中主要介绍五种算法: 1.选择排序; 2.插入排序; 3.快速排序; 4.合并排序; 5.堆排序; 在看下面之前,需要注意:有的算法语言表述比较乏力,在看下面博文时候要注意力在代码之上以下代码亲测可用;1.选择排序从数组一端选择一个数组中的一个元素,通过比较对比取出最小值(或者最大值)放在a

soullines的博客 6952

不带DDR的ZYNQ使用OCM加载程序运行的方法

软件版本:Vivado Vitis2019.2 第一步: 在Vivado的ZYNQ Block Design时候不配置DDR 第二步: 在Vitis中: 1、 在Vitis中新建Platform,选择xsa文件: 2、 在xparameters.h中添加DDR的地址空间定义,如下: 3、 修改链接文件,修改每个段都到ram_0,因为ram_1空间全部给到应用程序 4、 修改fsbl工程的main.c,增加XPAR_PS7_DDR_0条件编译 5、 修改fsbl.h,重定义DDR_EN

hpf247的博客 5538

浅析Java集合中的排序算法

通过该方法注释,查看到有三项值得关注的信息,大概意思是该方法实现了稳定且默认升序排序的功能。进入sort,代码进入到List类的sort方法,发现方法将入参list先转为了数组Object[],之后利用Arrays.sort进行排序。i.next();首先在这里思考一个问题为什么要转为数组,问题答案已经在方法的英文注释中说明白了。是为了避免直接对List的链表进行排序,从而耗费O(n2logn) 时间复杂度。

Java技术攻略的博客 285

从FinFET到NanoSheet:一文看懂TSMC制程技术的架构革命与性能飞跃

本文深入解析了TSMC从FinFET到NanoSheet的制程技术架构革命。FinFET通过三维立体结构解决了短沟道效应,而NanoSheet采用环绕栅极设计,实现了更强的静电控制与设计灵活性,结合EUV光刻技术,共同推动了芯片性能与能效的飞跃,为下一代AI与高性能计算奠定基石。

i3j4k5的博客 292

K8S 1.28.2 + Calico 3.27.3 保姆级安装避坑指南:解决节点NotReady问题

本文提供了一份详细的Kubernetes 1.28.2与Calico 3.27.3集群部署指南,重点解决节点NotReady这一常见问题。通过版本兼容性分析、精细化环境配置、kubeadm初始化参数详解及Calico Operator部署,手把手指导用户避开网络插件配置陷阱,确保集群从NotReady状态恢复健康并稳定运行。

weixin_28835583的博客 394

Java中的集合类有哪些常见的排序算法?

首先,我们创建了一个FileInputStream对象来读取名为"input.txt"的文件内容,并使用read()方法逐个读取文件中的字节,直到到达文件末尾。Java NIO(New IO)是Java 1.4版本中引入的一种新的I/O处理方式,它是对Java IO的一种改进和扩展。1. **快速排序(QuickSort)**:这是一种高效的排序算法,它使用分治法(Divide and Conquer)策略来把一个序列分为两个子序列,其中一个子序列的所有元素都比另一个子序列的元素小。

m0_58956056的博客 604

Java中的集合排序算法

通过该方法注释,查看到有三项值得关注的信息,大概意思是该方法实现了稳定且默认升序排序的功能。进入 sort,代码进入到 List 类的 sort 方法,发现方法将入参 list 先转为了数组 Object[],之后利用 Arrays.sort 进行排序。i.next();首先在这里思考一个问题为什么要转为数组,问题答案已经在方法的英文注释中说明白了。是为了避免直接对 List的链表进行排序,从而耗费 O(n2logn) 时间复杂度。

xxxzzzqqq_的博客 299

代码生成 | 安时积分法模型搭建

安时积分法是电池电量计量最基础的方法,今天我们用simulink建模的方式做一个安时积分模型,从而更好地理解安时积分的思想也掌握建模的基础操 ​新建文件 打开MATLAB启动simulink新建一个模型文件 定义变量 和手写代码一样,先定义几个后面要用到的变量,在simulink建模时新建变量用Data Store Memory模块。双击填入要定义的变量名,然后在signal attributes赋初值 如此方法新建四个变量current(电流)初值1000mA、tatol_cap(总容量

ningvay的博客 1万+

初识 QML

QML 是一种声明性语言,允许根据用户界面的可视组件以及它们如何相互交互和相互关联来描述用户界面。QML 是一种高度可读的语言,旨在使组件能够以动态方式互连,并且允许组件在用户界面中轻松重复使用和自定义。 使用 Qt Quick,开发人员可以轻松地在 QML 中构建流体动画用户界面,并且可以选择将这些用户界面连接到任何后端 C++ 库。

青春不老,奋斗不止! 1万+

总结梳理:Java 集合框架中排序算法的底层实现对比

集合/方法底层算法时间复杂度稳定性最佳场景TimSort稳定对象集合(如 ArrayList)Arrays.sort() (对象)TimSort稳定对象数组排序Arrays.sort() (原始类型)不稳定原始类型数组(高效内存)红黑树$O(\log n)$ 操作稳定动态有序集合,范围查询堆排序$O(\log n)$ 操作不稳定优先队列,极值操作TimSort (间接)稳定链表排序,但效率较低。

2501_94072303的博客 734

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

【Java-07】深入浅出排序算法、Map集合、集合嵌套

在 JDK5 中提供了可变参数,允许在调用方法时传入任意个参数。可变参数原理就是一个数组形式存在格式 : 修饰符 返回值类型 方法名(数据类型… 变量名) { }举例 : public void show(int … num) : 表达式该方法可以接收任意个整数值 , 原理 : 其实就是一个int类型的数组java.util.Map 集合,里面保存的数据是成对存在的,称之为双列集合。存储的数据,我们称为键值对。之前所学的Collection集合中元素单个单个存在的,称为单列集合。

接着奏乐接着舞的博客 2694

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

java集合提供的排序算法

java集合提供的排序算法 Arrays.sort()排序算法 如果数组长度大于等于286且连续性好的话,就用归并排序,如果大于等于286且连续性不好的话就用双轴快速排序。如果长度小于286且大于等于47的话就用双轴快速排序,如果长度小于47的话就用插入排序。 Collection.sort()的排序算法 如果LegacyMergeSort.userRequested为t...

kexinxin1的博客 515

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

Java集合与数据结构——七大排序算法的实现

七大基本排序算法

rain67的博客 1万+

在Java语言中 ,集合中的排序算法浅析

通过该方法注释,查看到有三项值得关注的信息,大概意思是该方法实现了稳定且默认升序排序的功能。进入sort,代码进入到List类的sort方法,发现方法将入参list先转为了数组Object[],之后利用Arrays.sort进行排序。i.next();首先在这里思考一个问题为什么要转为数组,问题答案已经在方法的英文注释中说明白了。是为了避免直接对List的链表进行排序,从而耗费O(n2logn) 时间复杂度。

u012181546的博客 517
上一篇: Java验证含空格的用户名
下一篇: Eclipse显示打印线
Android_Robot
博客等级 码龄15年 62粉丝 88原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值