高级排序-快速排序详解

最新推荐文章于 2023-07-18 17:23:34 发布
最新推荐文章于 2023-07-18 17:23:34 发布
阅读量681 收藏
点赞数 1
分类专栏： 数据结构与算法 数据结构与算法 文章标签： 快速排序 Quick Sort 排序 三路快排 分治
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love905661433/article/details/83144734
版权

辅助工具

概述

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

简单来说, 就是设定一个标准V, 每次遍历就将整个数组分成小于V和大于V的两部分, 这时,V就处于它在排好序的数组中应该在的位置, 然后再对左右两部分分别进行递归排序, 这个将数组分割成两部分的操作, 称之为partition, 下面看下代码实现 :

代码实现

package sort.quick;

import sort.Sort ;
import utils.ArrayUtil ;


public class QuickSort implements Sort {
	
	@Override
	public void sort(int [] arr) {
		quickSort(arr, 0, arr.length - 1);
	}
	
	/**
	 * 对数组arr的[l, r]前闭后闭的区间进行快速排序
	 * 递归方法
	 * @param arr
	 * @param l
	 * @param r
	 */
	private void quickSort(int [] arr, int l, int r){
		// 递归终止条件
		if (l >= r) {
			return;
		}
		
		int p = partition(arr, l, r);
		quickSort(arr, l, p - 1);
		quickSort(arr, p + 1, r);
	}
	
	/**
	 * 对arr数组的前闭后闭区间[l, r]进行partition操作
	 * @param arr
	 * @param l
	 * @param r
	 * @return 返回分割后作为标记元素的下标位置
	 */
	private int partition(int [] arr, int l, int r){
		// 设置用于对比的元素为arr[l]
				int v = arr[l];
				// arr[l + 1, j] <v; arr[j+1, i)>v
				int j = l;
				for (int i = l; i <= r; i++) {
					if (arr[i] < v) {
						ArrayUtil.swap(arr, i, j + 1);
						j++;
					}
				}
				ArrayUtil.swap(arr, l, j);
		return j;
	}
	
}

下面我们就可以测试一下快速排序和归并排序的性能之间的差异, 测试代码如下 :

	/**
	 * 测试插入排序和归并排序性能
	 */
	@Test
	public void testSort(){
		// 生成一个随机数组
		int[] arr = ArrayUtil.generateArray(1000000, 0, 1000000);
		int[] arr1 = ArrayUtil.copyArray(arr);
		int[] arr2 = ArrayUtil.copyArray(arr);
		int[] arr3 = ArrayUtil.copyArray(arr);
		int[] arr4 = ArrayUtil.copyArray(arr);
		System.out.println("----------------------------------随机数组----------------------------------") ;
		System.out.println("归并排序1 : " + ArrayUtil.testSort(arr1, new MergeSort()) + "s") ;
		System.out.println("归并排序2 : " + ArrayUtil.testSort(arr2, new MergeSort2()) + "s") ;
		System.out.println("归并排序3 : " + ArrayUtil.testSort(arr3, new MergeSort3()) + "s") ;
		System.out.println("自底向上的归并排序 : " + ArrayUtil.testSort(arr4, new MergeSortBU()) + "s") ;
		System.out.println("快速排序 : " + ArrayUtil.testSort(arr, new QuickSort()) + "s") ;
		/*
		 * 生成一个近乎有序的数组
		 * 100000 : 数组元素个数
		 * 10 : 在一个完全有序的数组上进行多少次元素交换
		 */
        arr = ArrayUtil.generateNearlyOrderedArray(1000000, 10);
		arr1 = ArrayUtil.copyArray(arr);
		arr2 = ArrayUtil.copyArray(arr);
		arr3 = ArrayUtil.copyArray(arr);
		arr4 = ArrayUtil.copyArray(arr);
		System.out.println("------------------------------近乎有序的数组------------------------------") ;
		System.out.println("归并排序1:" + ArrayUtil.testSort(arr1, new MergeSort()) + "s") ;
		System.out.println("归并排序2:" + ArrayUtil.testSort(arr2, new MergeSort2()) + "s") ;
		System.out.println("归并排序3:" + ArrayUtil.testSort(arr3, new MergeSort3()) + "s") ;
		System.out.println("自底向上的归并排序:" + ArrayUtil.testSort(arr4, new MergeSortBU()) + "s") ;
		System.out.println("快速排序 : " + ArrayUtil.testSort(arr, new QuickSort()) + "s") ;


	      /*
         * 生成一个存在大量重复元素的数组
         * 100000 : 数组元素个数
         */
        arr = ArrayUtil.generateArray(1000000, 0,  100);
        arr1 = ArrayUtil.copyArray(arr);
        arr2 = ArrayUtil.copyArray(arr);
        arr3 = ArrayUtil.copyArray(arr);
        arr4 = ArrayUtil.copyArray(arr);
        System.out.println("------------------------------存在大量重复元素的数组------------------------------") ;
        System.out.println("归并排序1:" + ArrayUtil.testSort(arr1, new MergeSort()) + "s") ;
        System.out.println("归并排序2:" + ArrayUtil.testSort(arr2, new MergeSort2()) + "s") ;
        System.out.println("归并排序3:" + ArrayUtil.testSort(arr3, new MergeSort3()) + "s") ;
        System.out.println("自底向上的归并排序:" + ArrayUtil.testSort(arr4, new MergeSortBU()) + "s") ;
        System.out.println("快速排序 : " + ArrayUtil.testSort(arr, new QuickSort()) + "s") ;

	}

测试结果如下 :

----------------------------------随机数组----------------------------------
归并排序1 : 0.205s
归并排序2 : 0.148s
归并排序3 : 0.154s
自底向上的归并排序 : 0.162s
快速排序 : 0.109s
------------------------------近乎有序的数组------------------------------
归并排序1:0.082s
归并排序2:0.047s
归并排序3:0.016s
自底向上的归并排序:0.02s
快速排序 : 60.363s
------------------------------存在大量重复元素的数组------------------------------
归并排序1:0.154s
归并排序2:0.114s
归并排序3:0.09s
自底向上的归并排序:0.09s
快速排序 : 3.401s

对于100万的数据量, 从上面的测试结果来说, 可以得到下面的结论 :

  • 对于随机数组来说, 快速排序的性能已经高于了归并排序了
  • 对于近乎有序的数组, 由于这个版本的在partition的过程中每次都取第一个元素作为标准, 这会导致partition分割的两部分严重不均衡, 在极端情况下即数组完全有序的情况下, 会退化成O(n²)级别的算法, 所以这个排序花了60多秒, 这个时间显然是不能接受的, 下面会进行优化
  • 对于存在大量重复元素的数组, 上面的代码其实是分成小于等于V和大于V的两部分, 一样是会造成partition的不平衡, 下面是对这些问题的优化方案

需要注意的一点是, 在对近乎有序的数组使用这一版的归并排序时, 会因为递归深度较深而占用大量栈空间, 如果报StackOVerflow的异常, 可以使用参数-Xss将栈空间设置大一点, 我这里设置了-Xss128m是没有问题的

排序优化

优化1

在上一篇归并排序的文章中就说过, 对于数据量较小的数组, 使用插入排序的性能反而更快, 所以可以在partition到底层数据量较小的时候, 使用插入排序替换快速排序, 进行第一次优化 :

package sort.quick;

import sort.Sort ;
import utils.ArrayUtil ;


/**
 * 快速排序优化
 * @author xuxiumeng
 *
 */
public class QuickSort2 implements Sort {
    
    @Override
    public void sort(int [] arr) {
        quickSort(arr, 0, arr.length - 1);
    }
    
    /**
     * 对数组arr的[l, r]前闭后闭的区间进行快速排序
     * 递归方法
     * @param arr
     * @param l
     * @param r
     */
    private void quickSort(int [] arr, int l, int r){
        // 递归终止条件
        if ( r - l < 16) {
            ArrayUtil.insertSort(arr, l, r);
            return;
        }
        
        int p = partition(arr, l, r);
        quickSort(arr, l, p - 1);
        quickSort(arr, p + 1, r);
    }
    
    /**
     * 对arr数组的前闭后闭区间[l, r]进行partition操作
     * @param arr
     * @param l
     * @param r
     * @return 返回分割后作为标记元素的下标位置
     */
    private int partition(int [] arr, int l, int r){
        // 设置用于对比的元素为arr[l]
                int v = arr[l];
                // arr[l + 1, j] <v; arr[j+1, i)>v
                int j = l;
                for (int i = l; i <= r; i++) {
                    if (arr[i] < v) {
                        ArrayUtil.swap(arr, i, j + 1);
                        j++;
                    }
                }
                ArrayUtil.swap(arr, l, j);
        return j;
    }
    
}

测试代码 :

	/**
	 * 测试插入排序和归并排序性能
	 */
	@Test
	public void testSort(){
		// 生成一个随机数组
		int[] arr = ArrayUtil.generateArray(1000000, 0, 1000000);
		int[] arr1 = ArrayUtil.copyArray(arr);
		int[] arr2 = ArrayUtil.copyArray(arr);
		int[] arr3 = ArrayUtil.copyArray(arr);
		int[] arr4 = ArrayUtil.copyArray(arr);
		int[] arr5 = ArrayUtil.copyArray(arr);
		System.out.println("----------------------------------随机数组----------------------------------") ;
		System.out.println("归并排序1 : " + ArrayUtil.testSort(arr1, new MergeSort()) + "s") ;
		System.out.println("归并排序2 : " + ArrayUtil.testSort(arr2, new MergeSort2()) + "s") ;
		System.out.println("归并排序3 : " + ArrayUtil.testSort(arr3, new MergeSort3()) + "s") ;
		System.out.println("自底向上的归并排序 : " + ArrayUtil.testSort(arr4, new MergeSortBU()) + "s") ;
		System.out.println("快速排序 : " + ArrayUtil.testSort(arr, new QuickSort()) + "s") ;
        System.out.println("快速排序2 : " + ArrayUtil.testSort(arr5, new QuickSort2()) + "s") ;

		/*
		 * 生成一个近乎有序的数组
		 * 100000 : 数组元素个数
		 * 10 : 在一个完全有序的数组上进行多少次元素交换
		 */
        arr = ArrayUtil.generateNearlyOrderedArray(1000000, 10);
		arr1 = ArrayUtil.copyArray(arr);
		arr2 = ArrayUtil.copyArray(arr);
		arr3 = ArrayUtil.copyArray(arr);
		arr4 = ArrayUtil.copyArray(arr);
	    arr5 = ArrayUtil.copyArray(arr);
		System.out.println("------------------------------近乎有序的数组------------------------------") ;
		System.out.println("归并排序1:" + ArrayUtil.testSort(arr1, new MergeSort()) + "s") ;
		System.out.println("归并排序2:" + ArrayUtil.testSort(arr2, new MergeSort2()) + "s") ;
		System.out.println("归并排序3:" + ArrayUtil.testSort(arr3, new MergeSort3()) + "s") ;
		System.out.println("自底向上的归并排序:" + ArrayUtil.testSort(arr4, new MergeSortBU()) + "s") ;
		System.out.println("快速排序 : " + ArrayUtil.testSort(arr, new QuickSort()) + "s") ;
        System.out.println("快速排序2 : " + ArrayUtil.testSort(arr5, new QuickSort2()) + "s") ;


	      /*
         * 生成一个存在大量重复元素的数组
         * 100000 : 数组元素个数
         */
        arr = ArrayUtil.generateArray(1000000, 0,  100);
        arr1 = ArrayUtil.copyArray(arr);
        arr2 = ArrayUtil.copyArray(arr);
        arr3 = ArrayUtil.copyArray(arr);
        arr4 = ArrayUtil.copyArray(arr);
        arr5 = ArrayUtil.copyArray(arr);
        System.out.println("------------------------------存在大量重复元素的数组------------------------------") ;
        System.out.println("归并排序1:" + ArrayUtil.testSort(arr1, new MergeSort()) + "s") ;
        System.out.println("归并排序2:" + ArrayUtil.testSort(arr2, new MergeSort2()) + "s") ;
        System.out.println("归并排序3:" + ArrayUtil.testSort(arr3, new MergeSort3()) + "s") ;
        System.out.println("自底向上的归并排序:" + ArrayUtil.testSort(arr4, new MergeSortBU()) + "s") ;
        System.out.println("快速排序 : " + ArrayUtil.testSort(arr, new QuickSort()) + "s") ;
        System.out.println("快速排序2 : " + ArrayUtil.testSort(arr5, new QuickSort2()) + "s") ;


	}

测试结果 :

----------------------------------随机数组----------------------------------
归并排序1 : 0.191s
归并排序2 : 0.143s
归并排序3 : 0.156s
自底向上的归并排序 : 0.16s
快速排序 : 0.109s
快速排序2 : 0.102s
------------------------------近乎有序的数组------------------------------
归并排序1:0.082s
归并排序2:0.047s
归并排序3:0.014s
自底向上的归并排序:0.021s
快速排序 : 134.718s
快速排序2 : 133.616s
------------------------------存在大量重复元素的数组------------------------------
归并排序1:0.183s
归并排序2:0.109s
归并排序3:0.086s
自底向上的归并排序:0.09s
快速排序 : 3.495s
快速排序2 : 3.481s

从测试结果看出, 这一版的快速排序比上一版的快速排序性能上要稍微好一点, 但是并没有借据近乎有序的数组, 和存在大量重复元素的数组性能较差的问题, 所以还需要继续优化

优化2

因为数组可能是近乎有序的数组, 所以我们可以不每次取队首的元素, 一种方案是每次随机取一个元素, 一种方案是取队首, 中间, 队尾三个元素中取大小排在中间的那个, 这里我们就使用随机元素的方案, 代码如下:

package sort.quick;

import java.util.Random;

import sort.Sort ;
import utils.ArrayUtil ;


/**
 * 快速排序优化
 * 上面两个版本的快速排序, 在处理近乎有序的数组的时候,性能很差, 
 * 因为每次partition时都取队首元素, 在数组近乎有序的时候, 会导致partition的两部分很不均匀
 * 在数组完全有序的情况下, 快速排序甚至会退化成O(n²)算法
 * 优化方案 : 每次随机取一个元素, 而不是每次取第一个元素
 * @author xuxiumeng
 *
 */
public class QuickSort3 implements Sort {
  private static Random random = new Random();
  
    @Override
    public void sort(int [] arr) {
        quickSort(arr, 0, arr.length - 1);
    }
    
    /**
     * 对数组arr的[l, r]前闭后闭的区间进行快速排序
     * 递归方法
     * @param arr
     * @param l
     * @param r
     */
    private void quickSort(int [] arr, int l, int r){
        // 递归终止条件
        if ( r - l < 16) {
            ArrayUtil.insertSort(arr, l, r);
            return;
        }
        
        int p = partition(arr, l, r);
        quickSort(arr, l, p - 1);
        quickSort(arr, p + 1, r);
    }
    
    /**
     * 对arr数组的前闭后闭区间[l, r]进行partition操作
     * @param arr
     * @param l
     * @param r
     * @return 返回分割后作为标记元素的下标位置
     */
    private int partition(int [] arr, int l, int r){
        // 获取用于对比的随机元素下标
        int randomNum = random.nextInt(r - l) + l;
        ArrayUtil.swap(arr, l, randomNum);
        // 设置用于对比的元素为arr[l]
        int v = arr[l];
        // arr[l + 1, j] <v; arr[j+1, i)>v
        int j = l;
        for (int i = l; i <= r; i++) {
            if (arr[i] < v) {
                ArrayUtil.swap(arr, i, j + 1);
                j++;
            }
        }
        ArrayUtil.swap(arr, l, j);
        return j;
    }
    
}

相比上一版, 这一版在排序的过程中仅仅多了如下两行代码 :

        // 获取用于对比的随机元素下标
        int randomNum = random.nextInt(r - l) + l;
        ArrayUtil.swap(arr, l, randomNum);

测试代码 :

	/**
	 * 测试插入排序和归并排序性能
	 */
	@Test
	public void testSort(){
		// 生成一个随机数组
		int[] arr = ArrayUtil.generateArray(1000000, 0, 1000000);
		int[] arr1 = ArrayUtil.copyArray(arr);
		int[] arr2 = ArrayUtil.copyArray(arr);
		int[] arr3 = ArrayUtil.copyArray(arr);
		int[] arr4 = ArrayUtil.copyArray(arr);
		int[] arr5 = ArrayUtil.copyArray(arr);
		int[] arr6 = ArrayUtil.copyArray(arr);
//		int[] arr7 = ArrayUtil.copyArray(arr);
		System.out.println("----------------------------------随机数组----------------------------------") ;
		System.out.println("归并排序1 : " + ArrayUtil.testSort(arr1, new MergeSort()) + "s") ;
		System.out.println("归并排序2 : " + ArrayUtil.testSort(arr2, new MergeSort2()) + "s") ;
		System.out.println("归并排序3 : " + ArrayUtil.testSort(arr3, new MergeSort3()) + "s") ;
		System.out.println("自底向上的归并排序 : " + ArrayUtil.testSort(arr4, new MergeSortBU()) + "s") ;
		System.out.println("快速排序 : " + ArrayUtil.testSort(arr, new QuickSort()) + "s") ;
        System.out.println("快速排序2 : " + ArrayUtil.testSort(arr5, new QuickSort2()) + "s") ;
        System.out.println("快速排序3 : " + ArrayUtil.testSort(arr6, new QuickSort3()) + "s") ;
//        System.out.println("三路快速排序 : " + ArrayUtil.testSort(arr7, new QuickSort3Ways()) + "s") ;

		/*
		 * 生成一个近乎有序的数组
		 * 100000 : 数组元素个数
		 * 10 : 在一个完全有序的数组上进行多少次元素交换
		 */
        arr = ArrayUtil.generateNearlyOrderedArray(1000000, 10);
		arr1 = ArrayUtil.copyArray(arr);
		arr2 = ArrayUtil.copyArray(arr);
		arr3 = ArrayUtil.copyArray(arr);
		arr4 = ArrayUtil.copyArray(arr);
	    arr5 = ArrayUtil.copyArray(arr);
	    arr6 = ArrayUtil.copyArray(arr);
//	    arr7 = ArrayUtil.copyArray(arr);
		System.out.println("------------------------------近乎有序的数组------------------------------") ;
		System.out.println("归并排序1:" + ArrayUtil.testSort(arr1, new MergeSort()) + "s") ;
		System.out.println("归并排序2:" + ArrayUtil.testSort(arr2, new MergeSort2()) + "s") ;
		System.out.println("归并排序3:" + ArrayUtil.testSort(arr3, new MergeSort3()) + "s") ;
		System.out.println("自底向上的归并排序:" + ArrayUtil.testSort(arr4, new MergeSortBU()) + "s") ;
		System.out.println("快速排序 : " + ArrayUtil.testSort(arr, new QuickSort()) + "s") ;
        System.out.println("快速排序2 : " + ArrayUtil.testSort(arr5, new QuickSort2()) + "s") ;
        System.out.println("快速排序3 : " + ArrayUtil.testSort(arr6, new QuickSort3()) + "s") ;
//        System.out.println("三路快速排序 : " + ArrayUtil.testSort(arr7, new QuickSort3Ways()) + "s") ;

	      /*
         * 生成一个存在大量重复元素的数组
         * 100000 : 数组元素个数
         */
        arr = ArrayUtil.generateArray(1000000, 0,  100);
        arr1 = ArrayUtil.copyArray(arr);
        arr2 = ArrayUtil.copyArray(arr);
        arr3 = ArrayUtil.copyArray(arr);
        arr4 = ArrayUtil.copyArray(arr);
        arr5 = ArrayUtil.copyArray(arr);
        arr6 = ArrayUtil.copyArray(arr);
//        arr7 = ArrayUtil.copyArray(arr);
        System.out.println("------------------------------存在大量重复元素的数组------------------------------") ;
        System.out.println("归并排序1:" + ArrayUtil.testSort(arr1, new MergeSort()) + "s") ;
        System.out.println("归并排序2:" + ArrayUtil.testSort(arr2, new MergeSort2()) + "s") ;
        System.out.println("归并排序3:" + ArrayUtil.testSort(arr3, new MergeSort3()) + "s") ;
        System.out.println("自底向上的归并排序:" + ArrayUtil.testSort(arr4, new MergeSortBU()) + "s") ;
        System.out.println("快速排序 : " + ArrayUtil.testSort(arr, new QuickSort()) + "s") ;
        System.out.println("快速排序2 : " + ArrayUtil.testSort(arr5, new QuickSort2()) + "s") ;
        System.out.println("快速排序3 : " + ArrayUtil.testSort(arr6, new QuickSort3()) + "s") ;
//        System.out.println("三路快速排序 : " + ArrayUtil.testSort(arr7, new QuickSort3Ways()) + "s") ;

	}

测试结果 :

----------------------------------随机数组----------------------------------
归并排序1 : 0.189s
归并排序2 : 0.142s
归并排序3 : 0.144s
自底向上的归并排序 : 0.15s
快速排序 : 0.115s
快速排序2 : 0.095s
快速排序3 : 0.099s
------------------------------近乎有序的数组------------------------------
归并排序1:0.082s
归并排序2:0.048s
归并排序3:0.016s
自底向上的归并排序:0.023s
快速排序 : 89.75s
快速排序2 : 83.944s
快速排序3 : 0.032s
------------------------------存在大量重复元素的数组------------------------------
归并排序1:0.177s
归并排序2:0.096s
归并排序3:0.088s
自底向上的归并排序:0.09s
快速排序 : 2.99s
快速排序2 : 2.803s
快速排序3 : 3.454s

可以看到仅仅多了两行代码, 这种情况下对于近乎有序的数组的排序性能提高了很多, 只是对于存在大量重复元素的数组, 排序性能还需要进一步进行优化

优化3 : 三路快排

对于存在大量重复元素的数组, 我们可以不仅仅将数组分割成两部分, 而是可以将数组分割成小于V, 等于V, 大于V的三部分, 然后对小于V和大于V的两部分在进行递归排序, 代码如下:

package sort.quick;

import java.util.Random;

import sort.Sort ;
import utils.ArrayUtil ;


/**
 * 快速排序优化
 * 上面快速排序的三个版本仍然存在一定的问题, 对于存在大量重复元素的数组, 
 * 排序的性能是远远低于归并排序的, 
 * 原因是因为每次进行partition实际是把数组分成小于等于v的元素和大于v的元素, 由于存在大量重复的元素
 * 所以会导致partition分割的两部分很不平衡
 * 
 * 优化方案 : 三路快排, 将数组分割成大于V,等于V, 小于V的三部分
 * @author xuxiumeng
 *
 */
public class QuickSort3Ways implements Sort {
  private static Random random = new Random();
  
    @Override
    public void sort(int [] arr) {
      quickSort3Ways(arr, 0, arr.length - 1);
    }
    
    /**
     * 对数组arr的[l, r]前闭后闭的区间进行快速排序
     * 递归方法
     * @param arr
     * @param l
     * @param r
     */
    private void quickSort3Ways(int [] arr, int l, int r){
        // 递归终止条件
        if ( r - l < 16) {
            ArrayUtil.insertSort(arr, l, r);
            return;
        }
        
        // 获取用于对比的随机元素下标
        int randomNum = random.nextInt(r - l) + l;
        ArrayUtil.swap(arr, l, randomNum);
        // 设置用于对比的元素为arr[l]
        int v = arr[l];
        
        // 设定arr[l+1...lt] < v, 初始情况下这个区间为空, 默认符合这个定义
        int lt = l; 
        // 设定arr[gt...r] > v, 初始情况下这个区间为空, 默认符合这个定义
        int gt = r + 1; 
        // arr[lt+1...i) == v, 初始情况下这个区间为空, 默认符合这个定义
        int i = l+1;
        // 在整个遍历过程中都保持arr[l+1...lt] < v, arr[gt...r] > v, arr[lt+1...i) == v
        while (i < gt) {
          if (arr[i] < v ) {
            ArrayUtil.swap(arr, i, lt + 1);
            lt++;
            i++;
           
          } else if (arr[i] > v) {
            // 这种情况下i的位置是从gt-1交换过来的元素, 仍然需要对这个元素进行判断, 所以这里不需要i++;
            ArrayUtil.swap(arr, i, gt - 1);
            gt--;
          } else {
            i++;
          }
        }
        
        ArrayUtil.swap(arr, l, lt);
        
        quickSort3Ways(arr, l, lt - 1);
        quickSort3Ways(arr, gt, r);
    }
    
}

测试代码 :

	/**
	 * 测试插入排序和归并排序性能
	 */
	@Test
	public void testSort(){
		// 生成一个随机数组
		int[] arr = ArrayUtil.generateArray(1000000, 0, 1000000);
		int[] arr1 = ArrayUtil.copyArray(arr);
		int[] arr2 = ArrayUtil.copyArray(arr);
		int[] arr3 = ArrayUtil.copyArray(arr);
		int[] arr4 = ArrayUtil.copyArray(arr);
		int[] arr5 = ArrayUtil.copyArray(arr);
		int[] arr6 = ArrayUtil.copyArray(arr);
		int[] arr7 = ArrayUtil.copyArray(arr);
		System.out.println("----------------------------------随机数组----------------------------------") ;
		System.out.println("归并排序1 : " + ArrayUtil.testSort(arr1, new MergeSort()) + "s") ;
		System.out.println("归并排序2 : " + ArrayUtil.testSort(arr2, new MergeSort2()) + "s") ;
		System.out.println("归并排序3 : " + ArrayUtil.testSort(arr3, new MergeSort3()) + "s") ;
		System.out.println("自底向上的归并排序 : " + ArrayUtil.testSort(arr4, new MergeSortBU()) + "s") ;
		System.out.println("快速排序 : " + ArrayUtil.testSort(arr, new QuickSort()) + "s") ;
        System.out.println("快速排序2 : " + ArrayUtil.testSort(arr5, new QuickSort2()) + "s") ;
        System.out.println("快速排序3 : " + ArrayUtil.testSort(arr6, new QuickSort3()) + "s") ;
        System.out.println("三路快速排序 : " + ArrayUtil.testSort(arr7, new QuickSort3Ways()) + "s") ;

		/*
		 * 生成一个近乎有序的数组
		 * 100000 : 数组元素个数
		 * 10 : 在一个完全有序的数组上进行多少次元素交换
		 */
        arr = ArrayUtil.generateNearlyOrderedArray(1000000, 10);
		arr1 = ArrayUtil.copyArray(arr);
		arr2 = ArrayUtil.copyArray(arr);
		arr3 = ArrayUtil.copyArray(arr);
		arr4 = ArrayUtil.copyArray(arr);
	    arr5 = ArrayUtil.copyArray(arr);
	    arr6 = ArrayUtil.copyArray(arr);
	    arr7 = ArrayUtil.copyArray(arr);
		System.out.println("------------------------------近乎有序的数组------------------------------") ;
		System.out.println("归并排序1:" + ArrayUtil.testSort(arr1, new MergeSort()) + "s") ;
		System.out.println("归并排序2:" + ArrayUtil.testSort(arr2, new MergeSort2()) + "s") ;
		System.out.println("归并排序3:" + ArrayUtil.testSort(arr3, new MergeSort3()) + "s") ;
		System.out.println("自底向上的归并排序:" + ArrayUtil.testSort(arr4, new MergeSortBU()) + "s") ;
		System.out.println("快速排序 : " + ArrayUtil.testSort(arr, new QuickSort()) + "s") ;
        System.out.println("快速排序2 : " + ArrayUtil.testSort(arr5, new QuickSort2()) + "s") ;
        System.out.println("快速排序3 : " + ArrayUtil.testSort(arr6, new QuickSort3()) + "s") ;
        System.out.println("三路快速排序 : " + ArrayUtil.testSort(arr7, new QuickSort3Ways()) + "s") ;

	      /*
         * 生成一个存在大量重复元素的数组
         * 100000 : 数组元素个数
         */
        arr = ArrayUtil.generateArray(1000000, 0,  100);
        arr1 = ArrayUtil.copyArray(arr);
        arr2 = ArrayUtil.copyArray(arr);
        arr3 = ArrayUtil.copyArray(arr);
        arr4 = ArrayUtil.copyArray(arr);
        arr5 = ArrayUtil.copyArray(arr);
        arr6 = ArrayUtil.copyArray(arr);
        arr7 = ArrayUtil.copyArray(arr);
        System.out.println("------------------------------存在大量重复元素的数组------------------------------") ;
        System.out.println("归并排序1:" + ArrayUtil.testSort(arr1, new MergeSort()) + "s") ;
        System.out.println("归并排序2:" + ArrayUtil.testSort(arr2, new MergeSort2()) + "s") ;
        System.out.println("归并排序3:" + ArrayUtil.testSort(arr3, new MergeSort3()) + "s") ;
        System.out.println("自底向上的归并排序:" + ArrayUtil.testSort(arr4, new MergeSortBU()) + "s") ;
        System.out.println("快速排序 : " + ArrayUtil.testSort(arr, new QuickSort()) + "s") ;
        System.out.println("快速排序2 : " + ArrayUtil.testSort(arr5, new QuickSort2()) + "s") ;
        System.out.println("快速排序3 : " + ArrayUtil.testSort(arr6, new QuickSort3()) + "s") ;
        System.out.println("三路快速排序 : " + ArrayUtil.testSort(arr7, new QuickSort3Ways()) + "s") ;

	}

测试结果 :

----------------------------------随机数组----------------------------------
归并排序1 : 0.197s
归并排序2 : 0.137s
归并排序3 : 0.163s
自底向上的归并排序 : 0.143s
快速排序 : 0.107s
快速排序2 : 0.102s
快速排序3 : 0.109s
三路快速排序 : 0.13s
------------------------------近乎有序的数组------------------------------
归并排序1:0.09s
归并排序2:0.05s
归并排序3:0.019s
自底向上的归并排序:0.026s
快速排序 : 92.938s
快速排序2 : 87.269s
快速排序3 : 0.035s
三路快速排序 : 0.064s
------------------------------存在大量重复元素的数组------------------------------
归并排序1:0.167s
归并排序2:0.092s
归并排序3:0.088s
自底向上的归并排序:0.088s
快速排序 : 3.503s
快速排序2 : 3.389s
快速排序3 : 2.252s
三路快速排序 : 0.036s

从测试结果来看, 三路快排基本上解决了各种问题, 虽然在对随机数组排序的性能上比之前几种稍差一点, 但是完全是在能接受的范围内, 影响不大

总结

  • O(nlogn)级别算法
  • 非稳定性算法, 算法稳定性可以参见上一篇递归排序里面的定义
七夜丶雪
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
头歌02-归并排序、快速排序
python一生之敌的博客
05-23 465
已知线性表L1中的数据序列是无序的，请设计归并排序算法和快速排序算法将线性表L1中的数据元素调整为非递减序列或非递增序列。
快速排序法（详解）
热门推荐
小白的博客
07-01 58万+
假设对以下10个数进行快速排序： 6 1 2 7 9 3 4 5 10 8 我们先模拟快速排序的过程：首先，在这个序列中随便找一个数作为基准数，通常为了方便，以第一个数作为基准数。 6 1 2 7 9 3 4 5 10 8 在初始状态下，数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位...
快速排序详解
感觉画质不如...原神的博客
04-10 1万+
快速排序（英语：Quicksort），又称分区交换排序（英语：partition-exchange sort），简称「快排」，是一种被广泛运用的排序算法。
排序算法 - 快速排序（4种方法实现）
originalHSL的博客
07-18 1万+
本文介绍了快速排序算法的挖坑法，前后指针法，左右指针法，非递归实现，以及使排序算法效率提高的三数取中
快速排序(详解)
liar________的博客
05-28 1966
快速排序是一种交换排序，交换就是根据序列中的两个记录键值的比较结果来兑换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。 快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。 ho...
【算法速成宝典】- 排序算法大揭秘：快速排序实战详解+实战题目库（积分解锁）
最新发布
07-10
本资源深度解析了快速排序算法原理及其实现步骤，涵盖从基础理论到高级技巧。提供详尽的实例解析与高质量代码示例，助力你轻松掌握快速排序，并挑战实战面试题。包含VIP专享的面试算法集锦，非零积分用户均可获取。...
Java排序算法详解.rar
03-23
本篇将深入探讨几种常见的Java排序算法，包括冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序以及TimSort等。 1. **冒泡排序**： 冒泡排序是最基础的排序算法，通过不断交换相邻的逆序元素来逐步排序。...
深入Java冒泡排序与选择排序的区别详解
09-05
冒泡排序和选择排序是两种基础的排序算法...在实际应用中，虽然冒泡排序和选择排序在效率上可能不如其他高级排序算法（如快速排序、归并排序等），但它们的简单性和易于理解性使它们成为初学者学习排序算法的良好起点。
删除运算排序-易语言.zip
10-05
删除运算排序常用于教学和理解排序算法原理，但在实际应用中，我们通常会选择更高效的排序算法，如快速排序、归并排序等。为了提高删除运算排序的效率，可以考虑在某些情况下结合其他排序算法，比如先使用插入排序对...
排序算法-基于C语言实现的排序算法之RadixSort实现.zip
03-27
尽管基数排序在小规模数据上可能不如其他高级排序算法（如快速排序、归并排序）快，但在处理大量数据时，其线性的运行时间优势非常明显。 总的来说，掌握基数排序不仅能够提升编程技能，还能够为处理大规模整数排序...
排序算法——快速排序.net实现
Leaderxin的博客
10-17 4674
排序算法——快速排序.net实现基本思想算法图例编码实现总结分析 基本思想 通过一趟排序将要排序的数据分割成独立的两个部分，一部分的所有数据都比另一部分所有的数据都要小，然后按照此方法对这两部分的数据分别进行快速排序，整个排序的过程可以递归进行，以此将整个数据变成有序的序列。 算法图例 假如我们现在要对“6 1 2 7 9 3 4 5 10 8” 这10个数进行排序，在上一篇中我们采用冒泡排序将相...
[排序算法]NET C# 快速排序 代码
ooo7880000的专栏
02-01 276
static void Main(string[] args) { var list = new int[] { 50, 70, 80, 60, 10, 40, 90, 30, 20 }; Console.WriteLine(String.Join(" ", list)); QuickSort(list, 0,
.net 快速排序 （实现）
08-17 1104
快速排序是对冒泡排序的一种改进。他的基本思想是，通过一趟排序将待排记录分割成独立的两部分。其中一部分记录的关键字比较均比另一部分的关键小，则可分为对这两部分记录继续进行排序。以达到整个序列有序。 int[] sortArray = new int[] { 45,36,54,2,
快速排序(彻底解析)
makabaka_sss_的博客
03-22 665
快速排序是七大排序速度最快的排序方法之一,分为一般快排,二路快排,三路快排, 一般使用递归实现,也可以使用非递归实现, 快排主要是partition()方法的不同,使得快速排序的性能不同,
快速排序详解（图解实例）
wy15027539821的博客
06-04 1万+
快速排序（Quicksort）是对冒泡排序的一种改进。 它的基本思想是：通过一趟排序将要排序的数据 分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法 对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 算法介绍 设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所...
快速排序图解_图解排序 4/10 快速排序
weixin_39612540的博客
11-22 220
快速排序，人称最快的排序(其实我不太赞同，只能说它整体上效率比较高，有些排序算法在特定的数据序列中远比快速排序效率高)。掌握快速排序，需要对递归有深入的了解，如果只是了解递归的用法「不知道为什么这样写」，却不知道递归原理和执行顺序，建议深入学习下递归思想(PS：公众号列表中已经躺了一篇关于递归的文章，只是没太想好如何能够通俗易懂把递归讲明白，后面我画一些图来聊一聊递归)。快速排序的核心思...
查找和排序算法1
08-04
快速排序使用分治法的思想，将数据集分成较小的子集，再对每个子集进行排序。最终将排好序的子集合并得到完整的有序序列。 2.5 归并排序 归并排序将数据集分成两个较小的子集，并对每个子集进行排序。然后将排好序...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值