十种排序算法的java汇总

最新推荐文章于 2024-07-05 10:45:36 发布
最新推荐文章于 2024-07-05 10:45:36 发布
阅读量241 收藏 2
点赞数
分类专栏： 牛客网 算法 文章标签： 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32742009/article/details/81201223
版权

作为一个数学系的coding菜鸟，还是得多多练习coding，花了一个多小时又手撸了一遍排序，这次把代码补全关了，果然有点不习惯～

排序算法算是基础中的基础，必须得多练。稍微讲一下要点吧。

冒泡排序：每一趟将相邻元素比较，将大的元素往后挪。每一趟可以把最大的元素放到未排序数组的末尾。可以实现成稳定的排序。时间复杂度为N-1+N-2+N-3+...+1 = N(N-1)/2 = O(N^2)。空间复杂度为O(1)

选择排序：每一趟从未排序的元素中选出最大的，与未排序数组的末尾交换。不稳定的排序。时间复杂度为O(N^2),空间复杂度为O(1)

插入排序：原始的插入排序是将新的元素插入到已经排序好的数组中去，找到排序好的数组中第一个大于当前元素的位置，然后依次交换过去。可以实现为稳定的排序，时间复杂度为O(N^2)，若数组已经有序，则为O(N)，与待排序数组的数据状况有关。

二分插入排序：原理与插入排序一样，只不过在查找排序好的数组中第一个大于当前元素的位置时用了二分查找，相比于顺序查找效率较高。同样为稳定的排序。

希尔排序：同样也是插入排序。因为插入排序的时间复杂度与待排序数组的数据状况有关，这个时间复杂度主要是在交换元素上。而希尔排序的核心思想就是慢慢使得整个待排序数组有序，这样每一次插入排序的交换元素耗时就会变小。通过设置一个gap，对每个相邻gap的元素进行直接插入排序。如果听不懂，你就这么想，当gap为1的时候就是直接插入排序。gap为2就是对1，3，5，7，9。。。。。位置的元素进行直接插入排序。注意希尔排序是不稳定的，其时间复杂度为O(n^1.3)~O(n^2)

归并排序：利用了分治的想法。关键在于如何Merge，具体不说了，网上有很多的图解，写的都很好。时间复杂度O(NlogN),空间复杂度O(N)，可以实现成稳定的排序。

快速排序：同样利用了分治的思想，关键在于Partition函数。时间复杂度为O(NlogN),最坏情况下为O(N^2)在基本排好序的情况下就很差，如果每次分区越均匀则速度越快。所以通常采用随机快排，随机选取分割点。是不稳定的排序。

堆排序：不稳定，时间复杂度为O(NlogN)

桶排序计数排序：

桶排序基数排序：

工程中的综合排序：

对数器：

下次再来填坑了～

import java.util.Arrays;

public class Main {
	public static void main(String[] args) {
		int[] arr = { 1, 11, 5, 10, 9, 4, 6, 4, 2, 0 };
		// BubbleSort(arr);
		// InsertionSort(arr);
		// BinaryInsertionSort(arr);
		// ShellSort(arr);
		// SelectionSort(arr);
		// MergeSort(arr);
		// QuickSort(arr);
		// HeapSort(arr);
		// BucketSort(arr);
		RadixSort(arr);
		for (int i : arr) {
			System.out.print(i + " ");
		}
		System.out.println();

		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			// BubbleSort(arr1);
			// InsertionSort(arr1);
			// BinaryInsertionSort(arr1);
			// ShellSort(arr1);
			// SelectionSort(arr1);
			// MergeSort(arr1);
			// QuickSort(arr1);
			// HeapSort(arr1);
			// BucketSort(arr1);
			RadixSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				succeed = false;
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
	}

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

	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; j--) {
				if (arr[j + 1] < arr[j])
					swap(arr, j, j + 1);
			}
		}
	}

	public static void BinaryInsertionSort(int[] arr) {
		if (arr == null || arr.length < 2)
			return;
		for (int i = 1; i < arr.length; i++) {
			int index = BinarySearch(arr, 0, i - 1, arr[i]);
			for (int j = i - 1; j >= index; j--)
				swap(arr, j, j + 1);
		}
	}

	public static int BinarySearch(int[] arr, int l, int r, int target) {
		int mid = 0;
		while (l <= r) {
			mid = l + ((r - l) >> 1);
			if (arr[mid] <= target)
				l = mid + 1;
			else
				r = mid - 1;
		}
		return l;
	}

	public static void ShellSort(int[] arr) {
		if (arr == null || arr.length < 2)
			return;
		int gap = arr.length;
		while (gap > 1) {
			gap = gap / 3 + 1;
			for (int i = gap; i < arr.length; i += gap) {
				for (int j = i - gap; j >= 0; j--) {
					if (arr[j + gap] < arr[j])
						swap(arr, j, j + gap);
				}
			}
		}
	}

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

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

	public static void MergeSort(int[] arr, int l, int r) {
		if (l < r) {
			int mid = l + ((r - l) >> 1);
			MergeSort(arr, l, mid);
			MergeSort(arr, mid + 1, r);
			Merge(arr, l, mid, r);
		}
	}

	public static void Merge(int[] arr, int l, int mid, int r) {
		int p1 = l;
		int p2 = mid + 1;
		int[] help = new int[r - l + 1];
		int i = 0;
		while (p1 <= mid && p2 <= r) {
			if (arr[p1] <= arr[p2])
				help[i++] = arr[p1++];
			else
				help[i++] = arr[p2++];
		}
		while (p1 <= mid)
			help[i++] = arr[p1++];
		while (p2 <= r)
			help[i++] = arr[p2++];
		for (int j = 0; j < help.length; j++)
			arr[l + j] = help[j];
	}

	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) {
			int[] p = Partition(arr, l, r);
			QuickSort(arr, l, p[0]);
			QuickSort(arr, p[1], r);
		}
	}

	public static int[] Partition(int[] arr, int l, int r) {
		swap(arr, r, l + (int) (Math.random() * (r - l + 1)));
		int val = arr[r]; // split standard.
		int p1 = l - 1;
		int p2 = r;
		while (l < p2) {
			if (arr[l] < val)
				swap(arr, l++, ++p1);
			else if (arr[l] > val)
				swap(arr, l, --p2);
			else
				l++;
		}
		swap(arr, p2++, r);
		return new int[] { p1, p2 };
	}

	public static void HeapSort(int[] arr) {
		if (arr == null || arr.length < 2)
			return;
		for (int i = 1; i < arr.length; i++)
			HeapInsert(arr, i);
		int size = arr.length;
		while (size > 1) {
			swap(arr, 0, --size);
			Heapify(arr, 0, size);
		}
	}

	public static void HeapInsert(int[] arr, int index) {
		while (index > 0) {
			if (arr[index] > arr[(index - 1) >> 1]) {
				swap(arr, index, (index - 1) >> 1);
				index = (index - 1) >> 1;
			} else
				return;
		}
	}

	public static void Heapify(int[] arr, int index, int size) {
		while ((index << 1) + 1 < size) {
			int leftchild = (index << 1) + 1;
			int childlargest = leftchild + 1 < size && arr[leftchild + 1] > arr[leftchild] ? leftchild + 1 : leftchild;
			int largest = arr[index] >= arr[childlargest] ? index : childlargest;
			if (largest == index)
				return;
			swap(arr, index, largest);
			index = largest;
		}
	}

	public static void BucketSort(int[] arr) {
		if (arr == null || arr.length < 2)
			return;
		int min = Integer.MAX_VALUE;
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < arr.length; i++) {
			min = arr[i] < min ? arr[i] : min;
			max = arr[i] > max ? arr[i] : max;
		}
		// 针对负数
		int[] buckets = new int[max - min + 1];
		for (int i = 0; i < arr.length; i++)
			arr[i] -= min;
		for (int i = 0; i < buckets.length; i++)
			buckets[i] = 0;
		for (int i = 0; i < arr.length; i++)
			buckets[arr[i]]++;
		int j = 0;
		for (int i = 0; i < buckets.length; i++)
			while (buckets[i] != 0) {
				arr[j++] = i;
				buckets[i]--;
			}
		for (int i = 0; i < arr.length; i++)
			arr[i] += min;
	}

	public static void RadixSort(int[] arr) {
		if (arr == null || arr.length < 2)
			return;
		final int radix = 10;
		RadixSort(arr, radix);
	}

	public static void RadixSort(int[] arr, int radix) {
		int maxbit = getmaxbit(arr, radix);
		int[] count = new int[radix];
		int[] buckets = new int[arr.length];

		for (int bit = 1; bit <= maxbit; bit++) {
			for (int i = 0; i < count.length; i++)
				count[i] = 0;
			for (int i = 0; i < arr.length; i++) {
				int digit = getdigit(arr[i], bit, radix);
				count[digit]++;
			}
			for (int i = 1; i < count.length; i++)
				count[i] += count[i - 1];
			for (int i = arr.length - 1; i >= 0; i--) {
				int digit = getdigit(arr[i], bit, radix);
				buckets[--count[digit]] = arr[i];
			}
			for (int i = 0; i < buckets.length; i++)
				arr[i] = buckets[i];
		}
	}

	public static int getmaxbit(int[] arr, int radix) {
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < arr.length; i++)
			max = arr[i] > max ? arr[i] : max;
		int bit = 0;
		while (max != 0) {
			bit++;
			max /= radix;
		}
		return bit;
	}

	public static int getdigit(int val, int bit, int radix) {
		return (int) ((val / (int) Math.pow(radix, bit - 1)) % radix);
	}

	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

	// for test
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			// arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue *
			// Math.random());
			arr[i] = (int) ((maxValue + 1) * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}
}

 

zhaosarsa
关注
专栏目录
Java 中的十大排序算法
半身风雪
04-05 818
1、冒泡排序 public class BubbleSort { public static int[] sort(int[] array) { if (array.length == 0) return array; /*循环数组长度的次数*/ for (int i = 0; i < array.length; i++){ /*从第0个元素开始，依次和后面的元素进行比较
算法 | Java 常见排序算法（纯代码）
m0_66784575的博客
03-27 1546
目录 汇总 1. 冒泡排序 1. 冒泡排序 每轮循环确定最值； public void bubbleSort(int[] nums) { int temp; boolean isSort = false; //优化，发现排序好就退出 for (int i = 0; i < nums.length-1; i++) { for (int j = 0; j < nums.length-1-i; j++) { //每次排序后能确定较大值 .
十大排序算法全面解析-Java实现
xfr140309的博客
01-15 595
前言 算法就是编程的灵魂，不会算法的程序员只配做码农。之前看到这句话受到一万点暴击伤害！同时也激起了自己的斗志，坦白说作为一个程序员，我一直知道算法的重要性，但是在算法这一块一直做的不够好，甚至除了大学学过这门课程之后就很少去接触它。因为一开始我就给算法贴上了难，烦，不怎么用的标签，现在想来其实都是在逃避问题。所以决定亡羊补牢，从头开始！ 介绍 算法的学习也是有着阶段性的，从入门到简单，再到复杂...
Java十大经典算法
最新发布
PurEandPure
07-05 347
（英语：Bubble Sort）又称为，是一种简单的。它重复地走访过要排序的，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。---维基百科。
十大排序算法Java
SEMHAQ的博客
03-20 1350
十大排序算法Java
java十大排序法_Java 十大排序算法
weixin_35282584的博客
02-27 268
目录：1、冒泡排序(Bubble Sort)2、选择排序(Selection Sort)3、插入排序(Insertion Sort)4、希尔排序(Shell Sort)5、归并排序(Merge Sort)6、快速排序(Quick Sort)7、堆排序(Heap Sort)8、计数排序(Counting Sort)9、桶排序(Bucket Sort)10、基数排序(Radix Sort)1、冒泡排序...
5种java排序算法汇总工具类
09-01
《Java排序算法汇总工具类详解》 在编程领域，排序算法是基础且至关重要的，它在数据处理和分析中扮演着重要角色。本文将详细解析Java中的五种常见排序算法：快速排序、希尔排序、插入排序、堆排序以及归并排序，并...
Java排序算法汇总大全.doc
09-01
Java排序算法汇总大全 在计算机科学中，排序算法是用于对数据序列进行排列的算法，以便根据特定标准对其进行组织。本文将详细介绍Java中常见的几种排序算法，并提供它们的基本原理、性能分析以及适用场景。 1. ...
java常用的7大排序算法汇总
06-29
以上介绍了Java中常用的四种排序算法，分别是插入排序、选择排序、冒泡排序和快速排序。这些排序算法各有特点，适用于不同的场景。例如，当数据量较小时，可以选择插入排序或选择排序；当数据量较大时，快速排序通常...
Java实现十大排序算法
木梓沐丶
11-26 1540
十大排序算法 十大排序算法分别为：冒泡排序、快速排序、插入排序、希尔排序、选择排序、堆排序、归并排序、桶排序、计数排序、基数排序 他们的时间复杂度分别为： 关于时间复杂度 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序； O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序 线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。 关于稳定性 稳定的排序算法：冒泡排序、插入排序、归并排序
用Java实现几种常见的排序算法
01-18
一起学习啊。。。。。。。。。。。。。。。。。。
排序算法汇总（java）
weixin_44080187的博客
05-19 255
算法解决思路，将复杂的算法拆分成简单的问题-》逐步解决。 1)类似于时间复杂度的讨论，一个算法的空间复杂度(Space Complexity)定义为该算法所耗费的存储空间，它也是问题规模n的函数。 2)空间复 杂度(Space Complexity)是对一个算法 在运行过程中临时占用存储空间大小的量度。有的算法需要占用的临时工作单元数与解决问题的规模n有关，它隨着n的增大而增大，当n较大时，将占用较多的存储单元，例如快速排序和归并排序算法,基数排序就属于这种情况。 3)在做算法分析时， 主要讨论的是时间复
十大经典排序算法的python实现
Alannah的个人学习记录
04-12 441
目录一 排序算法分类及时间复杂度二 算法讲解及python代码实现1.冒泡排序 Bubble Sort2.选择排序 Selection Sort3.插入排序 Insertion Sort4.快速排序 Quick Sort5.希尔排序 Shell Sort6.归并排序 Merge Sort7.堆排序 Heap Sort8.计数排序 Counting Sort9.桶排序 Bucket Sort10.基数排序 Radix Sort 贴一篇讲解贴，包含排序算法的动态展示图和算法讲解，本文将从该博客摘录重点并进行部分
Java实现：排序算法汇总
m0_63211569的博客
04-16 627
Java实现：排序算法汇总
十大排序算法（java实现）
m0_60469045的博客
05-10 985
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。【冒泡、插入、选择、、归并排序面试中出现概率极高】
Java | 数据结构 - 排序算法汇总【直接插入排序、希尔排序、冒泡排序、快速排序、直接选择排序……】（代码含注释，超详细）
日常记录
08-08 461
直接插入排序、希尔排序、冒泡排序、快速排序、直接选择排序、堆排序、归并排序、基数排序，算法性能汇总比较……
十种常见排序算法 JAVA版
wl20222022的博客
01-17 244
十种常见排序算法可以分为两大类： 非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。 线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。 根据此表整理了排序对比图，其中 1. 柱状图蓝色表示是稳定的，柱状图黄色表示不...
排序算法总结(Java版)
The__Apollo的博客
05-14 439
一.冒泡排序 冒泡排序，就是每次比较，大的元素往后挪，比较完第一遍后，最大的元素排到了数组的最后一位 。第二次比较，还是从第一个元素开始和后面的比较，把剩余的最大的元素拍到数组的倒数第二位，第一轮比较的最大元素不参与比较 。 程序实现： /*冒泡排序*/ public class Sort1 { public int[] sort(int[] nums){ int t...
JAVA排序算法详解与实现
"这篇文档是关于JAVA排序算法的汇总，涵盖了多种常见的排序算法，并提供了相关的JAVA实现。排序算法包括插入排序、交换排序、选择排序、归并排序和基数排序。文档还提到了根据数据规模和初始顺序选择合适排序算法的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值