常用排序算法（快速排序）

快速排序（Quicksort）是对冒泡排序的一种改进。设要排序的数组是 A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面， 这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。

更多信息请参考：http://baike.baidu.com/view/115472.htm

C语言代码：

#include <stdlib.h>
#include <stdio.h>
#include <memory.h>
#include <time.h>

void init(int *array, int count)
{
    int n = 0;
    srand((unsigned int)time(NULL));

    for (n=0; n<count; n++)
    {
        array[n] = rand()%100 + 1;
    }
}

void output(int *array, int count)
{
    int n = 0;
    for (n=0; n<count; n++)
    {
        printf("%5d", array[n]);
    }

    printf("\n");
}

/* 快速排序的具体实现，排正序 */  
void qsort_asc(int* array, int left, int right)   
{  
    int i = 0; 
    int j = 0;
    int pivot = 0;
    
    if (left < right)   
    {   
        // 这个条件用来结束递归  
        i = left;  
        j = right;  
        pivot= array[i]; 
         
        while (i < j)   
        {  
            while (i < j && array[j]>pivot)  
            {  
                j--; // 从右向左找第一个小于pivot的数  
            }  
              
            if (i < j)   
            {  
                array[i] = array[j];  
                i++;  
            }  
              
            while (i < j &&array[i]<pivot)  
            {  
                i++; // 从左向右找第一个大于pivot的数  
            }  
              
            if (i < j)   
            {  
                array[j] = array[i];  
                j--;  
            }  
        }  
          
        array[i] =pivot;  
        qsort_asc(array, left, i-1);  
        qsort_asc(array, i+1, right);  
    }  
}  

/* 快速排序的具体实现，排倒序 */  
void qsort_desc(int* array, int left, int right)   
{  
    int i = 0; 
    int j = 0;
    int pivot = 0;
    
    if (left < right)   
    {   
        // 这个条件用来结束递归  
        i = left;  
        j = right;  
        pivot= array[i]; 
         
        while (i < j)   
        {  
            while (i < j && array[j]<pivot)  
            {  
                j--; // 从右向左找第一个大于pivot的数  
            }  
              
            if (i < j)   
            {  
                array[i] = array[j];  
                i++;  
            }  
              
            while (i < j &&array[i]>pivot)  
            {  
                i++; // 从左向右找第一个小于pivot的数  
            }  
              
            if (i < j)   
            {  
                array[j] = array[i];  
                j--;  
            }  
        }  
          
        array[i] =pivot;  
        qsort_desc(array, left, i - 1);  
        qsort_desc(array, i + 1, right);  
    }  
}

/* 快速排序 */  
void quicksort(int* array, int count, int type)   
{  
    if (type == 0)   
    {   
        // 正排序，从小排到大  
        qsort_asc(array, 0, count-1);   
    }  
    else
    {   
        // 倒排序，从大排到小  
        qsort_desc(array, 0, count-1);
    }   
}

int main()
{
    const int count = 10;
    int array[count];

    memset(array, 0, sizeof(int)*count);

    init(array, count);
    
    printf("data before sort:      ");
    output(array, count);

    quicksort(array, count, 0);  // 正排序，从小排到大
    printf("data after sort(asc):  ");
    output(array, count);

    quicksort(array, count, 1);  // 倒排序，从大排到小
    printf("data after sort(desc): ");
    output(array, count);
    
    return 0;
}

运行结果如下：
data before sort:         19   87   46   71    6   35   10   51    8   68
data after sort(asc):      6    8   10   19   35   46   51   68   71   87
data after sort(desc):    87   71   68   51   46   35   19   10    8    6


Java代码：

import java.util.Random;

/**
* 快速排序 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。 步骤为：
* 1. 从数列中挑出一个元素，称为 "基准"（pivot）， 
* 2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
*    在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。
* 3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
*    递回的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递回下去，但是这个算法总会结束，
*    因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。       
*/

public class Sort 
{
	/*
	 * 输出数组中的数据
	 */
    public static void OutputArray(int[] array) 
    {
        for (int data : array) 
        {
            System.out.print(data + "\t");
        }
        
        System.out.println();
    }
    
    /*
     * 生成需要排序的数组
     */
    public static int[] createArray(int count) 
    {
        int array[] = new int[count];
        Random r = new Random();
        
        for (int i = 0; i < count; i++) 
        {
            array[i] = r.nextInt(100);
        }
        
        System.out.println("");
        System.out.print("data before sort:\t");
        
        OutputArray(array);
        
        return array;
    }
    
    /**
    * 快速排序 
    */
    public static void quickSort(int[] array, String sortType) 
    {
        if (sortType.equals("asc")) 
        { 
            // 正排序，从小排到大
            qsort_asc(array, 0, array.length - 1); 
        }
        else if (sortType.equals("desc")) 
        { 
            // 倒排序，从大排到小
            qsort_desc(array,0,array.length-1);
        } 
        else 
        {
            System.out.println("parameter input error.");
        }
    }
    
    /**
    * 快速排序的具体实现，排正序
    */
    public static void qsort_asc(int[] array, int left, int right) 
    {
        int i, j,pivot;
        if (left < right) 
        { 
            // 这个条件用来结束递归
            i = left;
            j = right;
            pivot= array[i];
            while (i < j) 
            {
                while (i < j && array[j]>pivot)
                {
                    j--; // 从右向左找第一个小于pivot的数
                }
                
                if (i < j) 
                {
                    array[i] = array[j];
                    i++;
                }
                
                while (i < j &&array[i]<pivot)
                {
                    i++; // 从左向右找第一个大于pivot的数
                }
                
                if (i < j) 
                {
                    array[j] = array[i];
                    j--;
                }
            }
            
            array[i] =pivot;
            qsort_asc(array, left, i - 1);
            qsort_asc(array, i + 1, right);
        }
    }

    /**
    * 快速排序的具体实现，排倒序
    */
    public static void qsort_desc(int[] array, int left, int right) 
    {
        int i, j,pivot;
        if (left < right) 
        { 
            // 这个条件用来结束递归
            i = left;
            j = right;
            pivot= array[i];
            while (i < j) 
            {
                while (i < j && array[j]<pivot)
                {
                    j--; // 从右向左找第一个大于pivot的数
                }
                
                if (i < j) 
                {
                    array[i] = array[j];
                    i++;
                }
                
                while (i < j &&array[i]>pivot)
                {
                    i++; // 从左向右找第一个小于pivot的数
                }
                
                if (i < j) 
                {
                    array[j] = array[i];
                    j--;
                }
            }
            
            array[i] =pivot;
            qsort_desc(array, left, i - 1);
            qsort_desc(array, i + 1, right);
        }
    }
    
    static int[] arr1=createArray(10);
    
    public static void main(String[] args) 
    {
        //int[] arr1=createArray(10);
        
        System.out.print("data after sort(asc):\t");
        quickSort(arr1, "asc");
        OutputArray(arr1);
        
        System.out.print("data after sort(desc):\t");
        quickSort(arr1, "desc");
        OutputArray(arr1);
    }
}

排序结果如下：
data before sort:    46    41    69    13    3    24    62    37    67    94    
data after sort(asc):    3    13    24    37    41    46    62    67    69    94    
data after sort(desc):    94    69    67    62    46    41    37    24    13    3