排序算法集合 -2

4. 快速排序 Quick Sort

快速排序的执行时间和空间： 平均情况为O(nlog(n))， 最差情况为O(n2)， 存储空间：O(log(n))。

//------------------------------------------------------------
void swap(int *a, int left, int right) {
    int temp = a[left];
    a[left] = a[right];
    a[right] = temp;
}

int partition(int *a, int left, int right) {
    if (NULL==a || left<0 || right<=0 || left>=right)
        return -1;

    int pivot = a[(left + right) / 2];
    while (left <= right) {
        // Find leftmost value greater than or equal to the pivot
        while (left<=right && a[left]<pivot)
            left++;
        // Find rightmost value less than or equal to the pivot
        while (left<=right && a[right]>pivot)
            right--;

        // swap
        if (left <= right) {
            swap(a, left, right);
            left++;
            right--;
        }
    }
    return left;
}

void Qsort(int *a, int left, int right) {
    if (NULL==a || left<0 || right<=0 || left>=right)
        return;

    int index = partition(a, left, right);
    if (left < index-1)
        Qsort(a, left, index-1);
    if (index < right)
        Qsort(a, index, right);
}

void quickSort(int *a, int len) {
    Qsort(a, 0, len-1);
}

// 方法2
// Quick Sort
    void quickSort(int *A, int l, int r) {
        if (l >= r) {
            return;
        }

        int i = l, j = r;
        int pivot = A[(l + r) / 2];

        while (i <= j) {
            // Find leftmost value greater than or equal to the pivot
            while (i <= j && A[i] < pivot) {
                i++;
            }
            // Find rightmost value less than or equal to the pivot
            while (i <= j && A[j] > pivot) {
                j--;
            }
            if (i <= j) {
                int temp = A[i];
                A[i] = A[j];
                A[j] = temp;
                i++;
                j--;
            }
        }

        quickSort(A, i, r);
        quickSort(A, l, j);
    }

void quickSort(int *a, int len) {
    quickSort(a, 0, len-1);
}