归并排序、快速排序——java实现

最新推荐文章于 2023-02-24 11:30:57 发布
最新推荐文章于 2023-02-24 11:30:57 发布
阅读量398 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： leetcode 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z1171127310/article/details/126577495
版权

1.归并排序

算法步骤：

  1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

  2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；

  3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

  4. 重复步骤 3 直到某一指针达到序列尾；

  5. 将另一序列剩下的所有元素直接复制到合并序列尾。

代码： 

public class MergeSort {

	// 递归方法实现
	public static void mergeSort1(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		process(arr, 0, arr.length - 1);
	}

	// arr[L...R]范围上，请让这个范围上的数，有序！
	public static void process(int[] arr, int L, int R) {
		if (L == R) {
			return;
		}
		// int mid = (L + R) / 2
		int mid = L + ((R - L) >> 1);
		process(arr, L, mid);
		process(arr, mid + 1, R);
		merge(arr, L, mid, R);
	}

	public static void merge(int[] arr, int L, int M, int R) {
		int[] help = new int[R - L + 1];
		int i = 0;
		int p1 = L;
		int p2 = M + 1;
		while (p1 <= M && p2 <= R) {
			help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
		}
		// 要么p1越界，要么p2越界
		// 不可能出现：共同越界
		while (p1 <= M) {
			help[i++] = arr[p1++];
		}
		while (p2 <= R) {
			help[i++] = arr[p2++];
		}
		for (i = 0; i < help.length; i++) {
			arr[L + i] = help[i];
		}
	}

	public static void mergeSort2(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		int step = 1;
		int N = arr.length;
		while (step < N) {
			int L = 0;
			while (L < N) {
				int M = 0;
				if (N - L >= step) {
					M = L + step - 1;
				} else {
					M = N - 1;
				}
				if (M == N - 1) {
					break;
				}
				int R = 0;
				if (N - 1 - M >= step) {
					R = M + step;
				} else {
					R = N - 1;
				}
				merge(arr, L, M, R);
				if (R == N - 1) {
					break;
				} else {
					L = R + 1;
				}
			}
			if (step > N / 2) {
				break;
			}
			step *= 2;
		}

	}

	// 非递归方法实现
//	public static void mergeSort2(int[] arr) {
//		if (arr == null || arr.length < 2) {
//			return;
//		}
//		int N = arr.length;
//		int mergeSize = 1;
//		while (mergeSize < N) {
//			int L = 0;
//			while (L < N) {
//				if (mergeSize >= N - L) {
//					break;
//				}
//				int M = L + mergeSize - 1;
//				int R = M + Math.min(mergeSize, N - M - 1);
//				merge(arr, L, M, R);
//				L = R + 1;
//			}
//			if (mergeSize > N / 2) {
//				break;
//			}
//			mergeSize <<= 1;
//		}
//	}

	// 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());
		}
		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();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		System.out.println("测试开始");
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			mergeSort1(arr1);
			mergeSort2(arr2);
			if (!isEqual(arr1, arr2)) {
				System.out.println("出错了！");
				printArray(arr1);
				printArray(arr2);
				break;
			}
		}
		System.out.println("测试结束");
	}

}

2.快速排序

算法步骤：

  1. 从数列中挑出一个元素，称为 "基准"（pivot）;

  2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

  3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

代码： 

public class PartitionAndQuickSort {

	public static void splitNum1(int[] arr) {
		int lessEqualR = -1;
		int index = 0;
		int N = arr.length;
		while (index < N) {
			if (arr[index] <= arr[N - 1]) {
				swap(arr, ++lessEqualR, index++);
			} else {
				index++;
			}
		}
	}

	public static void splitNum2(int[] arr) {
		int N = arr.length;
		int lessR = -1;
		int moreL = N - 1;
		int index = 0;
		// arr[N-1]
		while (index < moreL) {
			if (arr[index] < arr[N - 1]) {
				swap(arr, ++lessR, index++);
			} else if (arr[index] > arr[N - 1]) {
				swap(arr, --moreL, index);
			} else {
				index++;
			}
		}
		swap(arr, moreL, N - 1);
	}

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

	// arr[L...R]范围上，拿arr[R]做划分值，
	// L....R < = >
	public static int[] partition(int[] arr, int L, int R) {
		int lessR = L - 1;
		int moreL = R;
		int index = L;
		while (index < moreL) {
			if (arr[index] < arr[R]) {
				swap(arr, ++lessR, index++);
			} else if (arr[index] > arr[R]) {
				swap(arr, --moreL, index);
			} else {
				index++;
			}
		}
		swap(arr, moreL, R);
		return new int[] { lessR + 1, moreL };
	}

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

	public static void process(int[] arr, int L, int R) {
		if (L >= R) {
			return;
		}
		int[] equalE = partition(arr, L, R);
		process(arr, L, equalE[0] - 1);
		process(arr, equalE[1] + 1, R);
	}

	public static class Job {
		public int L;
		public int R;

		public Job(int left, int right) {
			L = left;
			R = right;
		}
	}

	public static void quickSort2(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		Stack<Job> stack = new Stack<>();
		stack.push(new Job(0, arr.length - 1));
		while (!stack.isEmpty()) {
			Job cur = stack.pop();
			int[] equals = partition(arr, cur.L, cur.R);
			if (equals[0] > cur.L) { // 有< 区域
				stack.push(new Job(cur.L, equals[0] - 1));
			}
			if (equals[1] < cur.R) { // 有 > 区域
				stack.push(new Job(equals[1] + 1, cur.R));
			}
		}
	}

	public static int[] netherlandsFlag(int[] arr, int L, int R) {
		if (L > R) {
			return new int[] { -1, -1 };
		}
		if (L == R) {
			return new int[] { L, R };
		}
		int less = L - 1;
		int more = R;
		int index = L;
		while (index < more) {
			if (arr[index] == arr[R]) {
				index++;
			} else if (arr[index] < arr[R]) {
				swap(arr, index++, ++less);
			} else {
				swap(arr, index, --more);
			}
		}
		swap(arr, more, R); // <[R] =[R] >[R]
		return new int[] { less + 1, more };
	}

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

	public static void process3(int[] arr, int L, int R) {
		if (L >= R) {
			return;
		}
		swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
		int[] equalArea = netherlandsFlag(arr, L, R);
		process3(arr, L, equalArea[0] - 1);
		process3(arr, equalArea[1] + 1, R);
	}

	// 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());
		}
		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();
	}

	// for test
	public static void main(String[] args) {
//		int[] arr = { 7, 1, 3, 5, 4, 5, 1, 4, 2, 4, 2, 4 };
//
//		splitNum2(arr);
//		for (int i = 0; i < arr.length; i++) {
//			System.out.print(arr[i] + " ");
//		}

		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		System.out.println("test begin");
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			int[] arr3 = copyArray(arr1);
			quickSort1(arr1);
			quickSort2(arr2);
			quickSort3(arr3);
			if (!isEqual(arr1, arr2) || !isEqual(arr1, arr3)) {
				System.out.println("Oops!");
				succeed = false;
				break;
			}
		}
		System.out.println("test end");
		System.out.println(succeed ? "Nice!" : "Oops!");

	}

}

朂後 哋箹萣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
归并排序、快速排序和堆排序的 Java 实现
Sorel的博客
03-14 727
归并排序递归版 package sort; public class MergeSortRecursively { public static void mergeSort(int[] array) { if (array == null || array.length &amp;lt;= 1) return; sort(array, 0...
归并排序——Java代码实现
pikachu_plus的博客
07-30 1372
归并排序（Mergesort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（DivideandConquer）的一个非常典型的应用。作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法*自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第2种方法）；*自下而上的迭代；...............
归并排序 以及面试题
我思故我在
10-22 168
归并排序时间复杂度：O（N*logN） 解法1：递归 思路：递归拆分每次分成两个，分到不能再分，分别排序有序然后再合并 /** * 归并排序 * @param arr */ public static void mergeSort1(int[] arr ){ //判断 是否需要排序 if(arr.length<2){ return; } proess(arr,0,arr.length-1); } /** * 递归分左右并且合并 * @para
归并排序&快速排序(Java)
chenyao的博客~
04-20 266
1.归并排序 1.1递推公式 归并排序分解图 递推公式： merge_sort(p…r) = merge(merge_sort(p…q), merge_sort(q+1…r)) 终止条件： p >= r 不用再继续分解 1.2代码实现 /** * 归并排序 * * @param value */ public static void mergeSort(int[] value) { mergeSort(value, 0, v
快速排序
puber~
05-30 232
package com.atguigu.sort; import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Date; public class QuickSort { public static void main(String[] args) { int[] arr = {-9,78,0,23,-567,70, -1,900, 4561}; quickSort(arr, 0,..
Java归并排序
Slayer_Zhao的博客
02-19 206
import org.junit.Test; public class MergeSort { //两路归并算法，两个排好序的子序列合并为一个子序列 public void merge(int []a,int left,int mid,int right){ int []tmp=new int[a.length];//辅助数组 int p1=lef...
排序之——直接插入排序、归并排序（优化）、快速排序（优化）
小小书童的博客
05-31 317
排序之——直接插入排序、归并排序（优化）、快速排序（优化）
java对数组实现选择排序（csdn）————程序.pdf
12-01
选择排序是一种简单直观的排序算法，它的...在实际开发中，人们通常会选择效率更高的排序算法，如快速排序、归并排序或堆排序。然而，了解并理解基本的排序算法如选择排序，对于学习和掌握更复杂的算法是非常有帮助的。
算法-归并排序（java）（csdn）————程序.pdf
12-05
下面将详细介绍归并排序算法的java实现。 什么是归并排序？ 归并排序是一种基于分治策略的排序算法。其基本思想是将一个大的无序数组分成两个或多个小数组，递归地将每个小数组排序，然后将排好序的子数组合并成一...
数据结构——排序算法（冒泡排序、选择排序、插入排序、归并排序、快速排序、搜索算法）
qq_52301431的博客
08-25 1107
如果有一天你面试的时候, 让你写一个排序算法, 你可以洋洋洒洒的写出多个排序算法, 但是如果其中没有快速排序, 那么证明你对排序算法也只是浅尝辄止, 并没有深入的研究过.- 对于N个数据项呢?- 如果2位置元素小于1位置的元素, 那么将0位置的元素移动到1位置, 并且将2位置的元素放在0位置, 0 - 1 - 2搞定.选择排序第一次将第0位置的人取出, 和后面的人(1, 2, 3...)依次比较, 如果后面的人更小, 那么就交换..........
Java实现快速排序和归并排序
Jamie's Blogs
10-11 514
Java实现快速排序和归并排序快速排序归并排序 快速排序 import java.util.Arrays; public class QuickSort01 { public static void main(String[] args) { int[] arr = {2, 9, 3, 1, 8, 4}; quick(arr, 0, arr.leng...
Java实现快速排序、归并排序
Mr.Qin
02-14 158
快速排序原理： 第一步：给定一个有若干元素的数组，在这个数组中选定一个基准数据（通常是第一个或最后一个）； 第二步：从数组两端开始依次轮流与基准数据比较，将比基准数据小的放到基准数据左边区间（或右边），将比其大的数据放到基准数据的右边区间（或左边）； 第三步：对左右两个区间分别重复第二步的操作，直到各区间只剩下一个数。 代码实现: package text; public class Test ...
快速排序与归并排序Java实现版
张可的博客
04-10 996
快速排序 快速排序（Quicksort） 是一种排序算法，平均时间复杂度为：O(n log n)，最坏需要 O(n²)，但很少见，快速排序之所以叫快速排序，就是因为它比一般的排序算法要快。 快速排序使用了分而治之的思想，步骤如下： 选择基准值（pivot） 将数组分成两个子数组：小于基准值的元素和大于基准值的元素 对这两个子数组进行快速排序 不同的选取基数值策略对排序性能都有很大的影响。 递归...
归并排序与快速排序（java）
maniacer的博客
06-26 189
归并排序 public class MergeSort { public static void main(String[] args) { int[] data = new int[]{6, 5, 4, 3, 2, 1}; mergeSort(data, 0, data.length - 1); System.out.println();...
（程序员面试题）归并排序
12-10 650
归并排序是效率仅次于快速排序的一种稳定排序，缺点是需要一块额外的空间用来存放需要处理的数据，具体代码如下： #include void merge(int num[], int start, int middle, int end) { int tmp1[10], tmp2[10]; int i, j, cur, len1, len2; int pos1, pos2;
2.1 归并排序及其相关面试题
qq_22783587的博客
03-09 152
1. 归并排序 分治思想，分成两个数组，不断分，直到分不了为止， 合并，直到所有的分数组合并完成 递归写法 public void sort(int[] arr) { if (L == R) { return; } } private void process(int[] arr; int L, int R) { if (L == R) { return; } int mid = L + ((R - L) >> 1); process(arr, L, mid); p
算法：归并排序面试题
OceanStar的博客
05-07 333
在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。举个栗子{1,3,4,2,5} 1左边比1小的数，没有 3左边比3小的数，1； 4左边比4小的数，1、3； 2左边比2小的数，1； 5左边比5小的数，1、3、4、2； 所以小和为1+1+3+1+1+3+4+2=16第一种思路就是暴力递归：这样时间复杂度太高了，所以我们可以转换一个思路另外，如果合并的时候相等怎么办？这个为什么快呢？因为在求小和的过程中后边子数组已经是有序的了，只要求出它的长度，在乘以当前数组的长度就可以求出小和的大小了，而
【数据结构】—— Java实现快速排序、归并排序
最新发布
qq_59599094的博客
02-24 567
Java实现快速排序、归并排序
归并排序+面试题
F的博客
09-21 412
归并排序 1）整体是递归，左边排好序+右边排好序+merge让整体有序 2）让其整体有序的过程里用了排外序方法 3）利用master公式来求解时间复杂度 4）当然可以用非递归实现 归并排序复杂度 T(N) = 2*T(N/2) + O(N^1) 根据master可知时间复杂度为O(N*logN) merge过程需要辅助数组，所以额外空间复杂度为O(N) 归并排序的实质是把比较行为变成了有序信息并传递，比O(N^2)的排序快 代码实现 package com.lzf2.class03; /** *
七大经典排序算法实现——Java版
"这篇资源主要介绍了7种经典的排序算法，并提供了Java语言的实现代码，包括冒泡排序、选择排序、快速排序、插入排序、希尔排序、归并排序和堆排序。" 在这篇资源中，我们可以深入理解7种不同的排序算法及其特点： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值