快速排序 quicksort

最新推荐文章于 2024-07-16 09:58:11 发布

原创最新推荐文章于 2024-07-16 09:58:11 发布 · 154 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#J# #SUN

数据结构专栏收录该内容

4 篇文章

订阅专栏

本文介绍了一种优化后的快速排序算法实现，通过选取中值作为枢轴、使用插入排序处理小规模数组等策略提高排序效率。并通过实验对比了该算法与Java内置排序方法的时间性能。

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

自己写的快速排序

测试效率：对于 20000 个随机数排序

插入排序：Time cost:2005ms
手写快排：Time cost:12ms
Sun API Arrays.sort() Time cost:3ms

import java.util.Arrays;
import java.util.Date;

// 快速排序
/**
 * author ： Jason liu
 * 有三点优化：
 * 1、选择 枢轴项时，选第一个元素、最后元素和中间元素的中值
 * 2、边缘效应，对于不大于10的子数组，采用简单的 插入排序
 * 3、总是先排序较小的子数组（空间效率高），本程序未采用
 */

public class Quicksort {

	// 私有化 构造函数，不可产生实例
	private Quicksort(){}
	
	public static  <T extends Comparable<T>> void sort(T[] list)
	{
		quick(list ,0, list.length-1);
		
		//边缘效应，对于长度不超过10的子数组，直接插入排序
		insertSort(list);
	}
	
	// 递归
	static <T extends Comparable<T>> void quick(T[] list, int lo, int hi)
	{
		if( (hi-lo)>10 )
		{
			// 分治 
			int splitPoint =split(list,lo,hi);
			quick(list, lo,splitPoint-1);
			quick(list, splitPoint+1,hi);
		}
	}
	
	
	// 分治
	static <T extends Comparable<T>> int split(T[] list, int lo, int hi)
	{
		// 获取枢轴项
		int median=getMedian(list,lo,hi);
		// 把枢轴项 放到 最前端
		T temp=list[lo];		list[lo]=list[median];	list[median]=temp;
		T piovt=list[lo];
		
		int left=lo+1;
		int right=hi;
		while(left<=right)
		{
			// 1 移动 左游标 left，获取第一个不小于 pivot的项
			while(left<=hi&&left<=right)
			{
				if(list[left].compareTo(piovt)>=0) break;
				left++;
			}
			// 2 移动 右游标 right，获取第一个小于 pivot 的项
			while(right>lo&&left<=right)
			{
				if(list[right].compareTo(piovt)<0) break;
				right--;
			}
			// 3 交换 获取的两项
			if(left<right)
			{
				temp=list[left];	list[left]=list[right];		list[right]=temp;
				left++;	 right--;
			}
		}
		// 交换 枢轴项
		temp=list[right];	list[right]=list[lo];	list[lo]=temp;
		return right;
	}
	
	//  获取枢轴项，选择第一个元素、中间元素和最后一个元素的中值
	static <T extends Comparable<T>> int getMedian(T[] list, int lo,int hi)
	{
		int mid=(lo+hi)/2;
		if(list[lo].compareTo(list[mid])<0)
		{
			if(list[mid].compareTo(list[hi])<0)	return mid;
			else if(list[lo].compareTo(list[hi])<0) return hi;
			else return lo;
		}
		else
		{
			if(list[lo].compareTo(list[hi])<0)	return lo;
			else if (list[mid].compareTo(list[hi])<0) return hi;
			else return mid;
		}
	}
	
	static <T extends Comparable<T>> void insertSort(T[] list)
	{
		T temp;
		int j;
		for(int i=1; i<list.length; i++)
		{
			j=i-1;
			temp=list[i];
			while(j>=0&&list[j].compareTo(temp)>0)
			{
				list[j+1]=list[j];
				j--;
			}
			list[j+1]=temp;
		}
	}
	
	public static void main(String[] args) {
		Integer [] arr=new Integer [20000];
		for(int i=0;i<arr.length;i++)
		{
			arr[i]=(int)(Math.random()*20000);
		}
	//	System.out.println(Arrays.toString(arr)+"\n");
		// insert sort:
		Date d1=new Date();
		Quicksort.<Integer>insertSort(arr);
		Date d2=new Date();
		System.out.println("Time cost:"+(d2.getTime()-d1.getTime()));
//		System.out.println(Arrays.toString(arr));		
		
		// quick sort:
		d1=new Date();
		Quicksort.<Integer>sort(arr);
		d2=new Date();
		System.out.println("Time cost:"+(d2.getTime()-d1.getTime()));
//		System.out.println(Arrays.toString(arr));			
		
		// Sun API
		d1=new Date();
		Arrays.sort(arr);
		d2=new Date();
		System.out.println("Time cost:"+(d2.getTime()-d1.getTime()));
//		System.out.println(Arrays.toString(arr));			
	}

}