快速排序

原地（In-place）分割版本的快速排序。

上面簡單版本的缺點是，它需要${\displaystyle \Omega (n)}$的額外儲存空間，也就跟归并排序一樣不好。額外需要的記憶體空間配置，在實際上的實作，也會極度影響速度和快取的效能。有一個比較複雜使用原地（in-place）分割算法的版本，且在好的基準選擇上，平均可以達到${\displaystyle O(\log n)}$空間的使用複雜度。

 function partition(a, left, right, pivotIndex)
 {
     pivotValue = a[pivotIndex]
     swap(a[pivotIndex], a[right]) // 把pivot移到結尾
     storeIndex = left
     for i from left to right-1
     {
         if a[i] < pivotValue
          {
             swap(a[storeIndex], a[i])
             storeIndex = storeIndex + 1
          }
     }
     swap(a[right], a[storeIndex]) // 把pivot移到它最後的地方
     return storeIndex
 }

這是原地分割演算法，它分割了標示為"左邊（left）"和"右邊（right）"的序列部份，藉由移動小於a[pivotIndex]的所有元素到子序列的開頭，留下所有大於或等於的元素接在他們後面。在這個過程它也為基準元素找尋最後擺放的位置，也就是它回傳的值。它暫時地把基準元素移到子序列的結尾，而不會被前述方式影響到。由於演算法只使用交換，因此最後的數列與原先的數列擁有一樣的元素。要注意的是，一個元素在到達它的最後位置前，可能會被交換很多次。

一旦我們有了這個分割演算法，要寫快速排列本身就很容易：

 procedure quicksort(a, left, right)
     if right > left
         select a pivot value a[pivotIndex]
         pivotNewIndex := partition(a, left, right, pivotIndex)
         quicksort(a, left, pivotNewIndex-1)
         quicksort(a, pivotNewIndex+1, right)

這個版本經常會被使用在命令式語言中，像是C語言。

亂數快速排序有一個值得注意的特性，在任意輸入資料的狀況下，它只需要${\displaystyle O(n\log n)}$的期望時間。是什麼讓隨機的基準變成一個好的選擇？

假設我們排序一個數列，然後把它分為四個部份。在中央的兩個部份將會包含最好的基準值；他們的每一個至少都會比25%的元素大，且至少比25%的元素小。如果我們可以一致地從這兩個中央的部份選出一個元素，在到達大小為1的數列前，我們可能最多僅需要把數列分割${\displaystyle 2\log _{2}n}$次，產生一個${\displaystyle O(n\log n)}$演算法。

不幸地，亂數選擇只有一半的時間會從中間的部份選擇。出人意外的事實是這樣就已經足夠好了。想像你正在翻轉一枚硬幣，一直翻轉一直到有${\displaystyle k}$次人頭那面出現。儘管這需要很長的時間，平均來說只需要${\displaystyle 2k}$次翻動。且在${\displaystyle k}$次翻動中得不到${\displaystyle k}$次人頭那面的機會，是像天文數字一樣的非常小。藉由同樣的論證，快速排序的遞迴平均只要${\displaystyle 2(2\log _{2}n)}$的呼叫深度就會終止。但是如果它的平均呼叫深度是${\displaystyle O(\log n)}$且每一階的呼叫樹狀過程最多有${\displaystyle n}$個元素，則全部完成的工作量平均上是乘積，也就是${\displaystyle O(n\log n)}$。

即使如果我們無法隨機地選擇基準數值，對於它的輸入之所有可能排列，快速排序仍然只需要${\displaystyle O(n\log n)}$時間。因為這個平均是簡單地將輸入之所有可能排列的時間加總起來，除以${\displaystyle n}$這個因數，相當於從輸入之中選擇一個隨機的排列。當我們這樣作，基準值本質上就是隨機的，導致這個演算法與亂數快速排序有一樣的執行時間。

更精確地說，對於輸入順序之所有排列情形的平均比較次數，可以藉由解出這個遞迴關係式可以精確地算出來。

${\displaystyle C(n)=n-1+{\frac {1}{n}}\sum _{i=0}^{n-1}(C(i)+C(n-i-1))=2n\ln n=1.39n\log _{2}n}$。

在這裡，${\displaystyle n-1}$是分割所使用的比較次數。因為基準值是相當均勻地落在排列好的數列次序之任何地方，總和就是所有可能分割的平均。

這個意思是，平均上快速排序比理想的比較次數，也就是最好情況下，只大約比較糟39%。這意味著，它比最壞情況較接近最好情況。這個快速的平均執行時間，是快速排序比其他排序演算法有實際的優勢之另一個原因。

被快速排序所使用的空間，依照使用的版本而定。使用原地（in-place）分割的快速排序版本，在任何遞迴呼叫前，僅會使用固定的額外空間。然而，如果需要產生${\displaystyle O(\log n)}$巢狀遞迴呼叫，它需要在他們每一個儲存一個固定數量的資訊。因為最好的情況最多需要${\displaystyle O(\log n)}$次的巢狀遞迴呼叫，所以它需要${\displaystyle O(\log n)}$的空間。最壞情況下需要${\displaystyle O(n)}$次巢狀遞迴呼叫，因此需要${\displaystyle O(n)}$的空間。

然而我們在這裡省略一些小的細節。如果我們考慮排序任意很長的數列，我們必須要記住我們的變數像是left和right，不再被認為是佔據固定的空間；也需要${\displaystyle O(\log n)}$對原來一個${\displaystyle n}$項的數列作索引。因為我們在每一個堆疊框架中都有像這些的變數，實際上快速排序在最好跟平均的情況下，需要${\displaystyle O(\log _{2}n)}$空間的位元數，以及最壞情況下${\displaystyle O(n\log n)}$的空間。然而，這並不會太可怕，因為如果一個數列大部份都是不同的元素，那麼數列本身也會佔據${\displaystyle O(n\log n)}$的空間位元組。

非原地版本的快速排序，在它的任何遞迴呼叫前需要使用${\displaystyle O(n)}$空間。在最好的情況下，它的空間仍然限制在${\displaystyle O(n)}$，因為遞迴的每一階中，使用與上一次所使用最多空間的一半，且

${\displaystyle \sum _{i=0}^{\infty }{\frac {n}{2^{i}}}=2n}$。

它的最壞情況是很恐怖的，需要

${\displaystyle \sum _{i=0}^{n}(n-i+1)=\Theta (n^{2})}$

空間，遠比數列本身還多。如果這些數列元素本身自己不是固定的大小，這個問題會變得更大；舉例來說，如果數列元素的大部份都是不同的，每一個將會需要大約${\displaystyle O(\log n)}$為原來儲存，導致最好情況是${\displaystyle O(n\log n)}$和最壞情況是${\displaystyle O(n^{2}\log n)}$的空間需求。