使用Java和Python实现快速排序算法

快速排序采用了分而治之的策略（divide and conquer,D&C）,一种著名的递归式问题解决方法。

分而治之的工作原理：

1. 找出简单的基线条件
2. 确定如何缩小问题的规模，使其符合基线条件

使用递归实现数组元素求和：

java版本

 public static int sum(int[] array){
        if(array.length <= 1){
            return array[0];
        }
        return array[0] + sum(Arrays.copyOfRange(array,1,array.length));
    }

编写涉及数组的递归函数时，基线条件通常是数组为空或只包含一个元素。

Python版本：

def sum(list):
    if list==[]:
        return 0
    return list[0]+sum(list[1:])

print (sum([1,2,3,4,5,6,7,8]))

使用递归计算列表包含的元素个数

java版本

public static int count(int[] array){
        if(array.length < 1){
            return 0;
        }
        return 1+count(Arrays.copyOfRange(array,1,array.length));
    }

Python版本

def count(list):
    if list == []:
        return 0
    return 1+count(list[1:])

print (count([1,2,3,4,5,6,7,8]))

找出数组中最大的数

java版本

 /**
     * 求最大值
     * @param array
     * @return
     */
    public static int max(int[] array){
        if(array.length == 2){
            return array[0] > array[1] ? array[0] : array[1];
        }
        int sub_max = max(Arrays.copyOfRange(array,1,array.length));
        return array[0] > sub_max ? array[0] : sub_max;
    }

Python版本

# 找出列表中最大的数字
def max(list):
    if len(list) == 2:
        return list[0] if list[0] > list[1] else list[1];
    sub_max = max(list[1:])
    return list[0] if list[0] > sub_max else sub_max

print (max([1,2,3,4,5,456,7,8]))

快速排序是一种常用的排序算法，比选择排序快得多

快速排序的基线条件是数组为空或只包含一个元素。这种情况下只需要返回原数组，根本不用排序。

快速排序的工作原理：

1. 从数组中选择一个元素，这个元素被称为基准值（pivot）。
2. 找出比基准值小的元素以及比基准值大的元素。这样被称为分区。

快速排序代码：

def quiksort(list):
    if len(list) < 2:
        return list
    else:
        pivot = list[0]
        less = [i for i in list[1:] if i <= pivot]
        greator = [i for i in list[1:] if i > pivot]

        return quiksort(less) + [pivot] + quiksort(greator)

print(quiksort([3,5,2,7,78,45,23]))

java版本

public class QuickSort {
    /**
     * 快速排序
     * @param array
     */
    public static void quickSort(int[] array,int less,int greater){
        //排序结束
        if(less >= greater){
            return;
        }
       int p = media(array,less,greater);
        quickSort(array,less,p-1);
        quickSort(array,p+1,greater);
        return;
    }

    /**
     * 每次以第一个元素即arr[l]为基准，比基准值小的在右，大的在左，
     * 返回基准值最终在数组中的位置
     * @param arr
     * @param less
     * @param greater
     * @return
     */
    private static int media(int[] arr, int less, int greater) {
        //基准值
        int v=arr[less];
        //基准值的位置
        int j=less;
        for(int i=less+1;i<=greater;i++) {
            //每次循环将小于v的往前换
            if(arr[i]<v) {
                swap(arr,i,j+1);
                j++; //arr[j+1]始终是大于v的,arr[j]是最后一个<=v的
            }
        }
        //再将基准值移动到中间
        swap(arr,less,j);
        //最终j所指的位置就是中间值
        return j;
    }

    /**
     * 交换i,j元素的位置
     * @param arr
     * @param i
     * @param j
     */
    private static void swap(int[] arr, int i, int j) {
        if(i!=j) {
            int temp =arr[j];
            arr[j]=arr[i];
            arr[i]=temp;
        }
    }

    public static void main(String[] args) {
        int[] array = {4,6,5,2,3,1};
        quickSort(array,0,array.length-1);
        System.out.println(Arrays.toString(array));
    }

}

只要每次都随机选择一个数组作为基准值，快速排序的平均运行时间将为O(nlogn)。快速排序是最快的排序算法之一。