java实现快速排序一种常规的，一种是左程云的方式。

最新推荐文章于 2024-02-20 20:32:48 发布
最新推荐文章于 2024-02-20 20:32:48 发布
阅读量1.8k 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： # java_笔试编程题 # java_sort
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Handsome2013/article/details/82858209
本文深入解析Java实现的快速排序算法，包括常规快排、改进版快排及左程云方式的快排。通过代码示例详细说明不同版本的实现细节与优化策略。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

java实现快速排序：

一：先来一个常规快排：

这个方式就是我们的基准值一直在两个边界徘徊，要么在less的较大边界，要么是在more的小边界，其实就是在居中位置徘徊。

package chapter1;



//来一个快排,常规快排
public class QuickSort {
	public static void main(String[] args) {
		int[] arr = { 1, 2, 7, 5, 4, 3, 9, 2, 7 };
		System.out.print("排序前     ");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+"  ");
		}
		System.out.println();
		quickSort(arr, 0, arr.length-1);
		System.out.print("排序后     ");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+"  ");
		}
	}

	public static void quickSort(int[] arr, int low, int high) {
		if (low < high) {//找出分割点，然后左分割，右分割
			int patition = patition(arr, low, high);
			quickSort(arr, low, patition-1);
			quickSort(arr, patition + 1, high);
		}
	}

	public static int patition(int[] arr, int low, int high) {
		int num = arr[low];// 我们取第一个作为基准值，而且基准值开始是在最低位
		while (low < high) {
			while (low < high && arr[high] > num) {
				high--;
			}
			swap(arr, low, high);//交换后，基准值跑到高位较小的位置了
			while (low < high && arr[low] <= num) {
				low++;
			}
			swap(arr, low, high);//交换后，基准值又跑到低位较大位置了
			
		}
		return low;

	}

	private static void swap(int[] arr, int low, int high) {
		int temp = arr[low];
		arr[low] = arr[high];
		arr[high] = temp;

	}
}

控制台打印如下：

下边一个和上边一个一样，只是有细微区别：

package sort;

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

	public static void quickSort(int[] arr, int small, int big) {
		// 来一个终止条件
		if (small >= big) {// 这个终止条件，不能是small==big，是因为在下边的左边来一波和右边来一波中，可能存在small大于big的
			return;
		}
		// 首先是找出分割点
		int mid = partition(arr, small, big);
		// 左边来一波
		quickSort(arr, small, mid - 1);
		// 右边来一波
		quickSort(arr, mid + 1, big);
	}

	private static int partition(int[] arr, int small, int big) {
		int num = arr[small];
		while (small < big) {
			while (small < big && num <= arr[big]) {
				big--;
			}
			swap(arr, small, big);
			while (small < big && num > arr[small]) {
				small++;
			}
			swap(arr, small, big);
		}
		return small;
	}

	private static void swap(int[] arr, int small, int big) {
		int temp = arr[small];
		arr[small] = arr[big];
		arr[big] = temp;

	}

}

控制台：

改进版本：就是添加了排除相等部分的重复排序：区别就是在左边和右边开始的时候，取的边界不一样

package chapter1;

//来一个快排,改进快排，我们多添加一个记录想等值。
public class QuickSort {
	public static void main(String[] args) {
		int[] arr = { 1, 2, 7, 5, 4, 3, 9, 2, 7 };
		System.out.print("排序前     ");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "  ");
		}
		System.out.println();
		quickSort(arr, 0, arr.length - 1);
		System.out.print("排序后     ");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "  ");
		}
	}

	public static void quickSort(int[] arr, int low, int high) {
		if (low < high) {
			int[] patition = patition(arr, low, high);
			quickSort(arr, low, patition[0] - patition[1]);
			quickSort(arr, patition[0] + 1, high);
		}
	}

	public static int[] patition(int[] arr, int low, int high) {
		int num = arr[low];// 我们取第一个作为基准值
		int equal = 0;// 这个用来记录等于基准值的数量，至少是1
		int result[] = new int[2];
		while (low < high) {
			while (low < high && arr[high] > num) {
				high--;
			}
			swap(arr, low, high);
			while (low < high && arr[low] <= num) {
				if (arr[low] == num) {
					equal++;
				}
				low++;
			}

			swap(arr, low, high);

		}
		result[0] = low;
		result[1] = equal;
		return result;

	}

	private static void swap(int[] arr, int low, int high) {
		int temp = arr[low];
		arr[low] = arr[high];
		arr[high] = temp;

	}
}

控制台：

二：左程云方式的快排

其实就是多了一部分，多了指出相等值的那部分，第二次就不需要再去重复排那些相等值的过程

 

首先来看一个问题：我们快排第一步是找一个基准值 ，然后右边值都大于基准值，左边值都小于基准值。

题目一：我随意给定一个数组和一个给定值，大于该值放右边，其他放左边，同时不能使用多余数组

package chapter1;

//需求：给一个数组，和其中一个数，将大于这个数和小于这个数的分成两边
public class GroupTest {
	public static void main(String[] args) {
		int[] arr = { 1, 2, 7, 5, 4, 3, 9, 2, 7 };
		int num = 6;
		group(arr, num);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]);
		}
	}

	public static void group(int[] arr, int num) {
		int p = 0;
		int small = 0;// 小数的边界
		int big = arr.length - 1;// 大数的边界
		while (small < big) {
			if (arr[p] < num) {
				exchange(arr, small, p);
				small++;
				p++;
			} else {
				exchange(arr, big, p);
				big--;

			}

		}
	}

	private static void exchange(int[] arr, int q, int p) {
		// TODO Auto-generated method stub
		int temp = arr[p];
		arr[p] = arr[q];
		arr[q] = temp;
	}
}

控制台：

 

通常我们选取最后一个或者第一个值为我们的基准值。下边我们选取最后一个值作为基准值，而且如果我们使用了把中间值拿过来放着后边不做比较，那么我们比较次数会更少一点

题目二：给定一个整型数组，然后以最后一个数为基准，将大于基准值的放右边，小于基准值放到左边。最后数组的情况就是，在基准值两边，一边是全部大于基准值，一边是全部小于基准值;

我们使用三个指针来区分三块，一块是小于区域，中间是等于区域，右边是大于区域。开始的时候，小于和大于区域都是在数组外边，要是存在一个符合要求的，就放到相应区域，同时该区域长度就增加1。如果是有一个小于的，首先交换当前值和less后边那个值，那么小于的区域的指针就++less,同时也会推着中间部分往右边跑，所以当前指针cur++;如果是满足大于区域，就把当前cur指向的数和大于那边的区域的边界more前边的那个数值交换，同时大于区域增加，就是--more,但是这里我们的cur就不变化。

 

 

 

代码：

package test2018926;

public class QuickSort {
	public static void main(String[] args) {
		Integer[] arr = { 1, 2, 7, 5, 4, 3 };
		partition(arr, 0, arr.length - 1);
	}

	public static Integer[] partition(Integer[] arr, int L, int R) {

		// 使用三个指针来将我们的数据分成三类，
		int cur = L;// 这个指向当前数据
		int less = L - 1;// 小数的前面一个
		int more = R + 1;// 大数的后边一个
		int num = arr[arr.length - 1];// 以最后一个值为基准来排出大于和小于
		Integer[] arr1 = new Integer[2];
		while (cur < more) {
			// System.out.println(cur);
			if (arr[cur] > num) {
				swap(arr, cur, --more);
			} else if (arr[cur] < num) {
				swap(arr, cur++, ++less);// less位置增加一个，就会推着cur向后
			} else {
				cur++;
			}
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]);
		}
		arr1[0] = less + 1;//等于num的左边界
		arr1[1] = more - 1;//等于num的右边界
		return arr1;
	}

	// 交换数组位置
	private static void swap(Integer[] arr, Integer m, Integer n) {
		int temp = arr[m];
		arr[m] = arr[n];
		arr[n] = temp;
	}
}

控制台打印：

 

 

题目三：下边讲解我们的改进快排：

快排就是不断细分，对一个小部分都进行上边相同的操作。

开始分为两边，然后对两边分别再分两边，一直分到最小，就是分成单个为止。

package test2018926;

public class QuickSort {
	public static void main(String[] args) {
		Integer[] arr = { 1, 2, 7, 5, 4, 3 };
		quickSort(arr, 0, arr.length - 1);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]);
		}
	}

	public static void quickSort(Integer[] arr, int L, int R) {
		if (L < R) {
			Integer[] p = partition(arr, L, R);// 返回的是相同数值区域的两个边界
			quickSort(arr, L, p[0] - 1);//p[0]是等于部分的左边界
			quickSort(arr, p[1] + 1, R);//p[1]是等于部分的右边界

		}

	}

	public static Integer[] partition(Integer[] arr, int L, int R) {

		// 使用三个指针来将我们的数据分成三类，
		int cur = L;// 这个指向当前数据
		int less = L - 1;// 小数的前面一个
		int more = R + 1;// 大数的后边一个
		int num = arr[arr.length - 1];// 以最后一个值为基准来排出大于和小于
		Integer[] arr1 = new Integer[2];
		while (cur < more) {
			// System.out.println(cur);
			if (arr[cur] > num) {
				swap(arr, cur, --more);
			} else if (arr[cur] < num) {
				swap(arr, cur++, ++less);// less位置增加一个，就会推着cur向后
			} else {
				cur++;
			}
		}
		for (int i = 0; i < arr.length; i++) {
			// System.out.print(arr[i]);
		}
		arr1[0] = less + 1;
		arr1[1] = more - 1;
		return arr1;
	}

	// 交换数组位置
	private static void swap(Integer[] arr, Integer m, Integer n) {
		int temp = arr[m];
		arr[m] = arr[n];
		arr[n] = temp;
	}
}

控制台打印：

左程云——归并排序和快速排序
m0_46266264的博客
07-29 988
递归 求中点位置，一般来说mid = （L+R）*0.5,这样写有一些问题 如果数组长度比较大，L+R可能会溢出，这样算出来的mid是不对的。 所以可以这么写 mid = L + (R-L)*0.5 //下面为右移一位（等同于除2），等同于上面 mid = L + (R-L)》》1 如下图就是递归的底层调用，相当于栈、树的后序遍历 p(0,5)要调用要先调用p(0,2),p(0,5)压入栈中， 同理，p(0,2)要先调用p(0,1)，p(0,2)压入栈中 p(0,1)要先调用p(0,0)，p(0,1)压
class 023 随机快速排序
最新发布
2301_80967814的博客
09-23 1371
这篇文章是看了“左程云”老师在b站上的讲解之后写的, 自己感觉已经能理解了, 所以就将整个过程写下来了。这个是“左程云”老师个人空间的b站的链接, 数据结构与算法讲的很好很好, 希望大家可以多多支持左程云老师, 真心推荐.
算法与数据结构全阶班-左程云版（二）基础阶段之3.归并排序和快速排序
CUFEECR的博客
02-21 1300
本文介绍了2种排序方式：归并排序，思路是整体为递归，左边排好序+右边排好序+ merge让整体有序，也可以用非递归实现，时间复杂度为O(N*logN)，额外空间复杂度为O(N)，相比于冒泡排序、选择排序和插入排序O(N2)的时间复杂度，归并排序的时间复杂度优化了很多，这是因为减少了比较次数，有很多应用，例如求小和、逆序对等，只要数组中左边的数比右边的数满足某个条件即可进行操作；快速排序有3种方式，普通分区算法，荷兰国旗算法，随机选数与最后一个数交换，再利用荷兰国旗算法，时间复杂度为O(N*logN)。
左程云算法通关023 随机快速排序
weixin_74776795的博客
02-20 576
前置知识：007 时间复杂度和空间复杂度——分析随机行为时间复杂度的部分。
左程云算法笔记（二）递归、mergeSort、荷兰国旗、快排
qq_42949310的博客
06-04 1057
左程云算法笔记（二）递归、mergeSort、荷兰国旗、快排
数据结构与算法XS班-左程云第八节课笔记（归并排序和快速排序）
DiPingXianhorizon的博客
03-12 973
这是数据结构与算法新手班-左程云第八课的笔记
左程云-基础入门班第1课代码.zip
12-27
左程云——基础入门班第1课代码 左程云——基础入门班第1课代码 左程云——基础入门班第1课代码 左程云——基础入门班第1课代码 左程云——基础入门班第1课代码 左程云——基础入门班第1课代码 左程云——基础入门班...
左程云leetcode-algo-in-java:java中的东西
06-30
左程云leetcode Algo In Java 数据结构和算法练习仓库 . ├── books │  └── codinginterviewguide 程序员算法面试指南-左程云 ├── ds ├── leetcode ├── nodes └── sortalgo
程序员代码面试指南（左程云 著） 的python代码实现版本，原书使用的是java版本.zip
11-14
python面试题、知识点，用于程序员应聘学习参考，提供代码+题型等资料 python面试题、知识点，用于程序员应聘学习参考，提供代码+题型等资料 python面试题、知识点，用于程序员应聘学习参考，提供代码+题型等资料 ...
左程云基础班——排序算法
weixin_46731597的博客
03-07 679
排序算法
左程云算法笔记（三）堆排序、桶排序、排序总结
qq_42949310的博客
06-09 1352
左程云算法笔记：堆排序、桶排序、排序总结
左程云代码java_左程云Java算法(1)
weixin_32746931的博客
02-28 547
1 public static void bubbleSort(int[] arr){2 if (arr == null || arr.length < 2){3 return;4 }5 for (int i=0; i arr[j+1]){8 swap(arr, j, j+1);9 }10...
堆排序算法java左程云_堆排序算法的java实现
weixin_36168629的博客
02-23 212
堆积排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法，可以利用数组的特点快速定位指定索引的元素。堆排序是不稳定的排序方法，辅助空间为O(1)， 最坏时间复杂度为O(nlog2n)，堆排序的堆序的平均性能较接近于最坏性能。中心思想是在使用数组存储的完全二叉树内从下往上每次构造大顶堆或者小顶堆，然后将找出来的堆顶数字放到数组结尾，剩下数组继续构造堆结构。主要是参考了网上比...
堆排序算法java左程云_堆排序算法以及JAVA实现
weixin_39702799的博客
02-23 243
堆的定义如下：n个元素的序列{k0,k1,...,ki,…,k(n-1)}当且仅当满足下关系时，称之为堆。" ki<=k2i,ki<=k2i+1;或ki>=k2i,ki>=k2i+1.(i=1,2,…,[n/2])"若将和此次序列对应的一维数组(即以一维数组作此序列的存储结构)看成是一个完全二叉树，则完全二叉树中每一个节点的值的都大于或等于任意一个字节的值(如果有的话)，称...
常见排序算法思路（参考左程云算法视频）
qq_45283095的博客
12-10 222
（1）选择排序：第一轮选择第1小的放在下标是0的位置，第i轮选择第i小的放在第i-1位置； （2）冒泡排序：假设数组长度是n，第一轮从第一个数两两比较到最后一个数，如果前一个数比后一个数大就交换，第i轮，从第一个数两两比较到倒数第i个数 （3）插入排序：第i轮保证前i轮有序，第i轮中，从第i个位置一直往前两两比较，如果前面的数大，就两两交换 （4）归并排序：先保证前半段有序，再保证后半段有序，再保证整体有序，对于前半段，再分成前半段和后半段，递归保证前半段和后半段有序； （5）快速排序：找到一个哨兵，将数组
快速排序 左神代码
fsdgfsf的博客
11-13 623
package basic_class_01; import java.util.Arrays; public class Code_04_QuickSort { public static void quickSort(int[] arr) { if (arr == null || arr.length < 2) { return; } quickSort(arr...
简单排序【左程云Java】
m0_63077733的博客
03-25 793
1.0，2.0版本，都有可能遇到划分的极端情况，左边区域很大，右边很小，复杂度就为 O ( N 2 ) O(N^2)O(N 2 )。
class2 快排、堆排和比较器（左程云左神算法 初级笔记 2018）
quanquanya的博客
04-20 1505
class 2 荷兰国旗问题 给定一个数组arr，和一个数num，请把小于num的数放在数组的左边，等于num的数放在数组的中间，大于num的数放在数组的右边。要求额外空间复杂度O(1)，时间复杂度O(N) public class NetherlandsFlag { public static void netherlandsFlag(int[] arr,int L,int R,in...
算法与数据结构——算法基础——排序理论(java)（b站左程云课程笔记总结）
Borslav的博客
06-14 305
算法与数据结构——排序理论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值