2. 程式人生 > >高階排序-快速排序詳解

高階排序-快速排序詳解

阿新 • • 發佈：2018-12-16

輔助工具

概述

快速排序由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 +

相關推薦

高階排序-快速排序詳解

輔助工具 概述 快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一部分的所有資料都要小，然後再按此方法對這兩部分資料分別進行快速排序，整個排序過程可以遞迴進行，

php冒泡排序與快速排序實例詳解

lag ++ function 開始 ret light 記錄 php冒泡排序 php $a=array(‘3‘,‘8‘,‘1‘,‘4‘,‘11‘,‘7‘); print_r($a); $len = count($a); //從小到大 for($i=1;$i<$le

二分查詢、快速排序對比和詳解

這兩個都是用到分治的思想很容易搞混。而且即使binarySearch是用到分治也不一定意味著一定要用遞迴去實現，可以通過迴圈實現。二分查詢和快速排序屬於面試筆試的高頻問題有必要總結一下。 由於迴圈相比遞迴少了很多記憶體分配和壓棧的操作開銷會少很多，所以

php中二維數組排序問題方法詳解

ges cti cmp each ace esc 對數 x11 用法 PHP中二維數組排序，可以使用PHP內置函數uasort() 示例一： 使用用戶自定義的比較函數對數組中的值進行排序並保持索引關聯 回調函數如下：註意回調函數的返回值是負數或者是false的時候，表

排序算法詳解

分治思想 分享 ray span 排序 排序算法 序列 jpg 兩個 1.歸並算法步驟: 1>分解:將無序序列不斷分裂,直到每個區間都只有一個數據為止(遞歸實現) 2>合並:將兩個區間合並為有序區間,一直合並到只有一個區間為止(分治思想) 下面代碼為歸

基礎排序算法詳解與優化

hit 12px lin width ffffff white n) 排序算法 orm 常見的基礎排序有選擇排序、冒泡排序和插入排序。眾所周知，他們的時間復雜度是 O(n\*n)。 但是，現在要重新認識一下基礎排序算法，尤其是“插入排序”：在近乎有序

【演算法】C++用連結串列實現一個箱子排序附原始碼詳解

01 箱子排序 1.1 什麼是分配排序？ 分配排序的基本思想：排序過程無須比較關鍵字，而是通過"分配"和"收集"過程來實現排序.它們的時間複雜度可達到線性階：O(n)。 1.2 什麼是箱子排序？ 箱子排序是分配排序的一種，箱子排序也稱桶排序(Bucket Sort)，其基本思想是：設定若干個箱子，依次掃描待

MySQL排序函式field()詳解

在日常開發過程中，排序是經常用到的，有時候有這樣的需求。 比如，需要在查詢結果中根據某個欄位的具體值來排序。如下面例子 上面是一張個人資訊 表，假如我們想按照'seiki','iris','xut'來排序。也就是name='seiki','iris','xut'的來排序。 碰到這樣的需求，我們應該怎麼做呢，

歸併排序（視訊+詳解+程式碼）

歸併排序 概述：歸併排序（MERGE-SORT）是建立在歸併操作上的一種有效的排序演算法,該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合併，得到

二分查詢 歸併排序 快排 詳解C++

這三個排序演算法一直是面試的重點，大多數都是C語言寫的，今天整理了一下C++的寫法，思想都差不多。這幾個排序經常忘記，今天抽空記在這，以便自己以後查閱，不對的地方，也歡迎大家評論，不吝指正，謝謝！ 二分查詢（時間複雜度是O(logn)） 二分查詢的基本思想是將n個元素分成大

【內部排序】八：歸併排序(Merge Sort)詳解與程式碼

歸併排序是多次將兩個或兩個以上的有序表合併成一個新的有序表。最簡單的歸併是直接將兩個有序的子表合併成一個有序的表。   2-路歸併排序 在內部排序中，通常採用的是2-路歸併排序。即：將含有n個元素的序

【資料結構週週練】034 奇偶排序演算法原理詳解及程式碼分享

一、氣泡排序 1、奇偶排序簡介 奇偶排序演算法不是嚴蔚敏老師書上的演算法，是今年某高校考研的一道考試題，聽朋友說了之後感覺很不錯，給大家分享一下。 題目大致含義如下： 已知奇偶交換排序如下所述： 1.第一趟對序列中所有奇數項i掃描，將a[i]和a[i+1]進行比較； 2.第二趟

Java陣列的高階部分:氣泡排序+選擇排序+直接插入排序+快速排序+折半查詢

1.氣泡排序 (1)氣泡排序的思想       兩兩比較,大的往後放,第一次比較完畢之後,最大值就出現在了最大索引處!然後依次這樣比較,就可以得到一個排好序的陣列. (2)氣泡排序的規律  1)一定是兩兩比較,大的往後放,第一次比較完畢,最大值在最大索引處  2)第

Hadoop Mapreduce分割槽、分組、連線以及輔助排序（也叫二次排序）過程詳解

package com.hadoop; import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; import org.apache.hadoop.conf.Configuration; import or

Leetcode 33 搜尋旋轉排序陣列 思路詳解+反思總結 python實現

本人一直在努力地積累Leetcode上用Python實現的題，並且會盡力講清每道題的原理，絕不像其他某些部落格簡略地帶過。如果覺得講的清楚，歡迎關注。題目：假設按照升序排序的陣列在預先未知的某個點上進行了旋轉。( 例如，陣列 [0,1,2,4,5,6,7] 可能變為 [4,5

排序演算法程式碼詳解

#include <iostream> using namespace std; void print(int a[], int len) {         for(int i = 0; i < len; i++)         cout <&l

Hadoop之MapReduce自定義二次排序流程例項詳解

一、概述 MapReduce框架對處理結果的輸出會根據key值進行預設的排序，這個預設排序可以滿足一部分需求，但是也是十分有限的。在我們實際的需求當中，往往有要對reduce輸出結果進行二次排序的需求。對於二次排序的實現，網路上已經有很多人分享過了，但是對二次排序的實現的

常用的八大排序演算法圖文詳解

概述排序有內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。我們這裡說說八大排序就是內部排序。    當n較大，則應採用時間複雜度為O(nlog2n)的排序方法：快速排序、堆排序或歸併

【內部排序】七：堆排序(Heap Sort)詳解與程式碼(超詳細註釋版)

堆排序是選擇排序的一種，每一趟從待排序的記錄中選出關鍵字最小的記錄，順序放在有序的子表中，直到全部記錄排序完畢。 我這裡做個總結： 二叉堆： 二叉堆其實是一棵有著特殊性質的完全二叉樹，父節點的值總

氣泡排序及優化詳解

演算法思想 　　氣泡排序屬於一種典型的交換排序。 　　交換排序顧名思義就是通過元素的兩兩比較，判斷是否符合要求，如過不符合就交換位置來達到排序的目的。氣泡排序名字的由來就是因為在交換過程中，類似水冒泡，小（大）的元素經過不斷的交換由水底慢慢的浮到水的頂端。 　　氣泡排序的思想就是利用的比較交換，利用迴圈