快速排序学习

快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

最坏情况运行时间为O(n2)。虽然这个最坏情况运行时间比较差，但快速排序通常是用于排序的最佳的实用选择，这是因为其平均性能相当好：期望的运行时间为O(nlgn)，且O(nlgn)记号中隐含的常熟因子很小。另外，它还能够进行就地排序，在虚拟环境中也能很好的工作。

#include<stdio.h>

#include<stdlib.h>

#define ARRAY_SIZE 10

/*
 QUICISORT(A, p ,r)
1       if p<r
2               then q = PRATITION(A, p ,r)
3               QUICKSORT(A, p, q-1)
4               QUICKSORT(A, q+1, r)


 PARTITION(A, p, r)
1       key = A[r]
2       i = p - 1
3       for j from p to r-1
4               do if A[j] <= key
5                  then i = i + 1
6                       exchange A[i]<->A[j]
7       exchange A[i+1]<->A[r]
8       return i+1
*/


int partition(int *, int, int);
void quick_sort(int *, int, int);
void exchange(int *, int, int);
void print_array(int *, int);
void quick_sort_firstoneiskey(int *, int, int);


int main(void)
{
        int a[ARRAY_SIZE] = {2,8,7,1,3,5,6,4,9,8};
        printf("before quick sort: \n");
        print_array(a, ARRAY_SIZE);

        quick_sort(a, 0, ARRAY_SIZE-1);
        printf("after quick sort: \n");
        print_array(a, ARRAY_SIZE);

        int age[ARRAY_SIZE] = {21, 32, 22, 18, 17, 19, 14, 30, 28, 20};
        printf("before quick sort: \n");
        print_array(age, ARRAY_SIZE);

        quick_sort_firstoneiskey(age, 0, ARRAY_SIZE-1);
        printf("after quick sort first one is key: \n");
        print_array(age, ARRAY_SIZE);


}


int partition(int * a, int p, int r)
{
        int key = a[r];
        int i = p - 1;
        int j = p;
        for(;j <= r - 1;j++)
        {
                if(a[j] <= key)
                {
                        i++;
                        exchange(a, i, j);
                }
        }
        exchange(a, i+1, r);

        return i+1;
}


void quick_sort(int * a, int p, int r)
{
        int q = 0;
        if(p < r)
        {
                q = partition(a, p, r);
                quick_sort(a, p, q-1);
                quick_sort(a, q+1, r);
        }
}


void exchange(int * a, int i, int j)

{

       if(i != j)

       {

                int temp = a[i];

                a[i] = a[j];

                a[j] = temp;

        }

}


void print_array(int * a, int size)
{
        int i = 0;
        for(; i < size; i++)
                printf("%d ", a[i]);
        putchar('\n');
}


void quick_sort_firstoneiskey(int * a, int p, int r)
{
        if(p >= r) return;

        int i = p, j = r, key = a[p];
        while(i < j)
        {
                for(; j > i; j--)
                {
                        if(a[j] < key)
                        {
                                a[i] = a[j];
                                break;
                        }
                }
                for(; i < j; i++)
                {
                        if(a[i] > key)
                        {
                                a[j] = a[i];
                                break;
                        }
                }
        }

        a[i] = key;

        quick_sort_firstoneiskey(a, p, i-1);
        quick_sort_firstoneiskey(a, i+1, r);

}

================================================================================================================

#!/usr/bin/python

def exchange(array, i, j):

    temp = array[i]
    array[i] = array[j]
    array[j] = temp


def partition(array, p, r):

    key = array[r]
    i = p - 1
    for j in range(p,r):
        if array[j] <= key:
            i = i + 1
            exchange(array, i, j)
    exchange(array, i+1, r)
    return i+1


def quick_sort(array, p, r):

    if p < r:
        q = partition(array, p, r)
        quick_sort(array, p, q-1)
        quick_sort(array, q+1, r)


def main():

    a = [2,8,7, 1, 3, 5, 6, 4, 9, 8]
    quick_sort(a, 0, 9)
    print a