快速排序 && 尋找第K大(小)的數

參考：https://minenet.me/2016/08/24/quickSort.html

快速排序

利用分治法可將快速排序的分為三步：

1. 在數據集之中，選擇一個元素作為”基准”。
2. 所有小於”基准”的元素，都移到”基准”的左邊；所有大於”基准”的元素，都移到”基准”的右邊。這個操作稱為分區 (partition) 操作，分區操作結束后，基准元素所處的位置就是最終排序后它的位置。
3. 對”基准”左邊和右邊的兩個子集，不斷重復第一步和第二步，直到所有子集只剩下一個元素為止。

def quickSort(arr, left, right):
    if left >= right:
        return
    low, high = left, right
    key = arr[low]
    while low < high:
        while low < high and arr[high] >= key:
            high -= 1
        arr[low], arr[high] = arr[high], arr[low]
        while low < high and arr[low] <= key:
            low += 1
        arr[low], arr[high] = arr[high], arr[low]
    quickSort(arr, left, low-1)
    quickSort(arr, low+1, right)

if __name__ == '__main__':
    arr = [4, 5, 2, 1, 5, 8, 3, 2, 6]
    quickSort(arr, 0, len(arr)-1)
    print arr

Java

import java.util.Scanner;

public class Main{
    private void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public void quickSort(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int key = arr[left], low = left, high = right;
        while (low < high) {
            while (low < high && arr[high] > key) {
                high--;
            }
            swap(arr, low, high);
            while (low < high && arr[low] < key) {
                low++;
            }
            swap(arr, low, high);
        }
        quickSort(arr, left, low-1);
        quickSort(arr, low+1, right);
    }

    public static void main(String[] args) {
        Main mainObj = new Main();
        Scanner in = new Scanner(System.in);
        while(in.hasNext()) {
            int n = Integer.parseInt(in.next());
            int[] a = new int[n];
            for (int i=0; i<n; i++) {
                a[i] = Integer.parseInt(in.next());
            }
            mainObj.quickSort(a, 0, a.length-1);
            System.out.println("Sorted a : ");
            for (int i=0; i<a.length; i++) {
                System.out.print(a[i] + " ");
            }
        }
        in.close();
    }
}

尋找第K大(小)的數

尋找第K小的數：

1. 快速排序中確定基准值后，將數組分為兩部分，基准元素前面的一定小於基准元素。后面的大於基准元素。
2. 如果基准元素前面的元素個數大於K個，則第K小的數一定在基准元素的前面，沒必要進行后面的排序。否則就在后面，沒必要前面的排序
3. 直到這個基准元素的位置剛好是K-1

# 尋找第K小的數
def kNum(arr, k):
    if not arr or k <= 0 or k > len(arr):
        return None
    index = partition(arr, 0, len(arr)-1)
    while k-1 != index:
        if k-1 < index:
            index = partition(arr, 0, index-1)
        else:
            index = partition(arr, index+1, len(arr)-1)
    return arr[k-1]

def partition(arr, low, high):
    key = arr[low]
    while low < high:
        while low < high and arr[high] >= key:
            high -= 1
        arr[low], arr[high] = arr[high], arr[low]
        while low < high and arr[low] <= key:
            low += 1
        arr[low], arr[high] = arr[high], arr[low]
    return low

if __name__ == '__main__':
    arr = [4, 5, 2, 1, 5, 8, 3, 2, 6]
    print kNum(arr,9)