在講解快速排序之前，先來說一說遞歸和棧。

遞歸

通俗地講，一個函數調用自己本身，就是遞歸。每個遞歸函數都有兩部分：基線條件(函數不再調用自己)和遞歸條件(函數調用自己)。
示例：

def countdown(i):
  print i
  #基線條件
  if i <= 0:
    return
  #遞歸條件
  else:
    countdown(i-1)

棧

棧：僅允許在表的一端進行插入和刪除運算的線性表。棧有兩種操作：入棧和出棧。所有函數調用都進入調用棧，在使用遞歸函數時，可能使得調用棧很長，這將占用大量的內存。

快速排序

1.分而治之(divide and conquer)——一種著名的遞歸式問題解決方法，有興趣的自行百度學習。
2.百度百科對快速排序的解釋：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然后再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
3.步驟：

1.選擇基準值
2.將數組分成兩個子數組:小于基準值的元素組成的數組和大于基準值的元素組成的數組。
3.對子數組進行快速排序。

scala實現代碼：

object KuaiSu{
    def main(args: Array[String]) = {
        var sortArray = Array(45, 26, 34, 2, 888, 54, 23, 45, 76, 2);
        sort(sortArray,0,9);
        for(i <- sortArray){
            println(i);
        }
    }
    def sort(array:Array[Int],low:Int,high:Int):Unit={
        if(low < high){
            var l:Int = low;
            var h:Int = high;
            var base:Int = array(low);
            while(l<h){
                while(l<h && array(h)>=base){
                    h = h - 1;
                }
                if(l < h){
                    array(l) = array(h);
                    l = l + 1;
                }

                while(l< h && array(l) < base){
                    l= l + 1;
                }
                if(l < h){
                    array(h) = array(l);
                    h = h - 1;
                }
            }
            array(l) = base;

            sort(array,low,l-1);
            sort(array,l+1,high);
        }
    }
}

Java代碼實現：

import java.util.Arrays;

public class MyClass {
    public static void main(String[] args){
        int[] sortArray = {45, 26, 34, 2, 888, 54, 23, 45, 76, 2};
        sort(sortArray,0,9);
        System.out.println(Arrays.toString(sortArray));
    }

    private static void sort(int arr[],int low,int high){
        //當數組長度大于1
        if(low < high){
            int l = low;
            int h = high;
            int base = arr[low];

            //循環結束將數組分成2部分
            while (l<h){
                //右-->左，查找小于base的數
                while(l<h && arr[h]>=base){
                    h--;
                }
                if(l<h){
                    arr[l] = arr[h];
                    l++;
                }

                //左-->右，查找大于base的數
                while (l<h && arr[l] < base){
                    l++;
                }
                if(l<h){
                    arr[h] = arr[l];
                    h--;
                }
            }

            //填坑
            arr[l] = base;

            //遞歸
            sort(arr,low,l-1);
            sort(arr,l+1,high);
        }
    }
}

結果圖：

SYJ.png

Python實現代碼一：

def quickSort(L,low,high):
    l = low
    h = high

    if l >= h:
        return L

    base = L[l]

    while l < h:
        while l<h and L[h]>=base:
            h = h-1
        if l<h:
            L[l] = L[h]
            l=l+1
        while l<h and L[l] <= base:
            l = l+1
        if l<h:
            L[h] = L[l]
            h=h-1

    L[l] = base

    quickSort(L,low,l-1)
    quickSort(L,h+1,high)
    return L
x = [45, 26, 34, 2, 888, 54, 23, 45, 76, 2]
print(quickSort(x,0,9))

Python實現代碼二：

def quickSort(array):
    if len(array)<2:
        return array
    else:
        base = array[0]
        #小于等于基準值的元素組成的數組
        less = [i for i in array[1:] if i<=base]
        #大于基準值的元素組成的數組
        greater = [i for i in array[1:] if i> base]
        #將數組串起來
        return quickSort(less)+[base]+quickSort(greater)

print(quickSort([45, 26, 34, 2, 888, 54, 23, 45, 76, 2]))

結果圖：

SYJ.png

OC實現代碼：

#import "ViewController.h"

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    NSMutableArray *array = [[NSMutableArray alloc] initWithObjects:@45, @26, @34, @2, @888, @54, @23, @45, @76, @2, nil];
    [self kuaisuArray:array andLow:0 andHigh:9];
    NSLog(@"%@",array);

}
-(void)kuaisuArray:(NSMutableArray*)array andLow:(NSInteger)low andHigh:(NSInteger)high{
    if(low < high){
        NSInteger l = low;
        NSInteger h = high;
        int base = [array[low] intValue];
        
        while(l<h){
            //右-->左，查找小于base的數
            while(l<h && [array[h] intValue]>=base){
                h--;
            }
            if(l<h){
                array[l] = array[h];
                l++;
            }
            
            //左-->右，查找大于base的數
            while (l<h && [array[l] intValue] < base){
                l++;
            }
            if(l<h){
                array[h] = array[l];
                h--;
            }
        }
        
        array[l] = [NSNumber numberWithInt:base];
        
        [self kuaisuArray:array andLow:low andHigh:l-1];
        [self kuaisuArray:array andLow:l+1 andHigh:high];
    }
}
@end

結果圖：

SYJ.png