1. 以array[0]为基准，比array[0]小的组合为数组less，比array[0]大的组合为数组more，递归实现快速排序。

例如：对“[6,1,4,7,3,10,5,2,9,8]”这个10个数进行排序

第一次调用函数，6为基数，less＝［1,4,3,5,2］,more=[7,10,9,8]

第二次调用函数，1为基数，less=[ ]，more=[4,3,5,2], more调用函数后，4为基数：less=[3,2]，more=[5]等等递归

#!/usr/bin/python
def quickSort(a):
      less = []
       more = []
       equal = []
 if len(a) <= 1:
             return a
 else:
            key=a[0]
             for i in a:
                 if i < key:
                              less.append(i)

                 elif i > key:
                            more.append(i)
          
                 else:
                            equal.append(i)

       less = quickSort(less)
  more = quickSort(more)
  array = less+equal+more
     return array

if __name__ == "__main__":
   arr = [6, 1, 4, 7, 3, 10, 5, 2, 9, 8]
 print quickSort(arr)

2. 方法：

以array[0]为基准，其余的数和array[0]比较，先从右边比较，j－－，找到比其小的数的位置；再从左边往后比较，i++，找到比其大的数的位置，交换array[i]和array[j]。然后继续比较，直到i=j，把array[0]和array[i]交换位置。至此，第一轮比较完成。接下来递归，直到按升序排列成功。

例如：对“6 1  2 7  9 3  4  5 10 8”这个10个数进行排序，6位基准数。

第一次交换位置：6 1 2 5 9 3 4 7 10 8

第二次：6 1 2 5 4 3 9 7 10 8

最后一次，array[i]array[j]都指向3，交换6和3，变成3 6 1 2 5 4 6 9 7 10 8，完成。

接下来递归操作。

#!/usr/bin/python


def quicksort(a,low,high):

        if low>=high:

                return a

        else:

                j=high

                i=low

                key=a[low]

                while low!=high:

                        while lowand a[high]>=key:   ＃等号＝很重要

                                high-=1

                        while lowand a[low]<=key:       ＃等号＝很重要

                                low+=1

                        if low
                            a[low], a[high] = a[high], a[low]

                            print a

                a[i]=a[low]

                a[low]=key



                quicksort(a,0,low-1)

                quicksort(a,low+1,j)

                return a


if __name__=="__main__":

        array=[6,1,2,7,9,3,4,5,10,8]

        print array

        low=0

        high=len(array)-1

        print quicksort(array,0,high)

3.以key=a[0]为基准，从右边j--的位置开始比较与a[0]的大小，比a[0]小的数，交换位置：a[low],a[high]=a[high],a[low]；然后从左边i++的位置开始，比较与key的大小，比key大的数，交换位置：a[low],a[high]=a[high],a[low].直到low=high。然后将a[high]=key。第一遍排序结束，接下来递归。

该方法的基本思想是：

1．先从数列中取出一个数作为基准数。

2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3．再对左右区间重复第二步，直到各区间只有一个数。

虽然快速排序称为分治法，但分治法这三个字显然无法很好的概括快速排序的全部步骤。因此我的对快速排序作了进一步的说明：挖坑填数+分治法：

先来看实例吧，定义下面再给出（最好能用自己的话来总结定义，这样对实现代码会有帮助）。

以一个数组作为示例，取区间第一个数为基准数。

初始时，i = 0;  j = 9;   X = a[i] = 72

由于已经将a[0]中的数保存到X中，可以理解成在数组a[0]上挖了个坑，可以将其它数据填充到这来。

从j开始向前找一个比X小或等于X的数。当j=8，符合条件，将a[8]挖出再填到上一个坑a[0]中。a[0]=a[8]; i++;  这样一个坑a[0]就被搞定了，但又形成了一个新坑a[8]，这怎么办了？简单，再找数字来填a[8]这个坑。这次从i开始向后找一个大于X的数，当i=3，符合条件，将a[3]挖出再填到上一个坑中a[8]=a[3]; j--;

数组变为：

 i = 3;   j = 7;   X=72

再重复上面的步骤，先从后向前找，再从前向后找。

从j开始向前找，当j=5，符合条件，将a[5]挖出填到上一个坑中，a[3] = a[5]; i++;

从i开始向后找，当i=5时，由于i==j退出。

此时，i = j = 5，而a[5]刚好又是上次挖的坑，因此将X填入a[5]。

数组变为：

可以看出a[5]前面的数字都小于它，a[5]后面的数字都大于它。因此再对a[0…4]和a[6…9]这二个子区间重复上述步骤就可以了。

对挖坑填数进行总结

1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。

2．j--由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。

3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。

4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。

#!/usr/bin/python
def quickSort(a, low, high):

    if low >= high:

        return a

    else:

        key = a[low]

        j = high

        while low != high:

            while low < high and a[high] >= key:

                high -= 1

            if a[high] < key:

                a[low], a[high] = a[high], a[low]

            while low < high and a[low] <= key:

                low += 1

            if a[low] > key:

                a[low], a[high] = a[high], a[low]

        a[low] = key

        j = low

        quickSort(a, 0, low - 1)

        quickSort(a, low + 1, j)

        return a




if __name__ == "__main__":

    arr = [6, 1, 4, 7, 9, 5, 2, 3, 10, 8]

    high = len(arr) - 1

    print quickSort(arr, 0, high)