快速排序(oc/java/python/scala)

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

遞迴

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

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);
        }
    }
}複製程式碼

結果圖：

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]))複製程式碼

結果圖：

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複製程式碼

結果圖：