快速排序——Kotlin、Java实现

2019独角兽企业重金招聘Python工程师标准>>>

##转载请标明出处 http://coderknock.com 快速排序（Quicksort）是对冒泡排序的一种改进。

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

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

一趟快速排序的算法是： 1）设置两个变量i、j，排序开始的时候：i=0，j=N-1； 2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]； 3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换； 4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换； 5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

快速排序之所比较快，因为相比冒泡排序，每次交换是跳跃式的。每次排序的时候设置一个基准点，将小于等于基准点的数全部放到基准点的左边，将大于等于基准点的数全部放到基准点的右边。这样在每次交换的时候就不会像冒泡排序一样每次只能在相邻的数之间进行交换，交换的距离就大的多了。因此总的比较和交换次数就少了，速度自然就提高了。当然在最坏的情况下，仍可能是相邻的两个数进行了交换。因此快速排序的最差时间复杂度和冒泡排序是一样的都是O(N2)，它的平均时间复杂度为O(NlogN)。其实快速排序是基于一种叫做“二分”的思想。

###Kotlin实现：

import java.util.*

/**
 * 拿客 www.coderknock.com
 * 三产 创建于 2016年06月23日 23:49:39。
 * 快速排序Kotlin版
 */
fun main(args: Array) {
    //要进行排序的数组
    val sortArray = IntArray(10)
    val ra = Random()
    //生成随机数，对这个随机数数组进行排序
    println("随机数组：")
    for (i in sortArray.indices) {
        sortArray[i] = ra.nextInt(100)
        print("${sortArray[i]} ")
    }
    println()
    sort(sortArray, 0, sortArray.size - 1)
    println("排序后的数组：")
    for (i in sortArray) {
        print("${i} ")
    }
}
fun sort(sortArray: IntArray, leftIndex: Int, rightIndex: Int) {
    var leftIndexTemp = leftIndex
    var rightIndexTemp = rightIndex
    if (leftIndex > rightIndex)
        return
    //基准数
    val cardinalNum = sortArray[leftIndex]
    while (leftIndexTemp != rightIndexTemp) {
        //顺序很重要，要先从右边开始找
        while (sortArray[rightIndexTemp] >= cardinalNum && leftIndexTemp < rightIndexTemp)
            rightIndexTemp--
        //再找右边的
        while (sortArray[leftIndexTemp] <= cardinalNum && leftIndexTemp < rightIndexTemp)
            leftIndexTemp++
        //交换两个数在数组中的位置
        if (leftIndexTemp < rightIndexTemp) {
            sortArray[leftIndexTemp] = sortArray[leftIndexTemp] xor sortArray[rightIndexTemp]
            sortArray[rightIndexTemp] = sortArray[leftIndexTemp] xor sortArray[rightIndexTemp]
            sortArray[leftIndexTemp] = sortArray[leftIndexTemp] xor sortArray[rightIndexTemp]
        }
    }
    sortArray[leftIndex] = sortArray[leftIndexTemp]
    sortArray[leftIndexTemp] = cardinalNum
    sort(sortArray, leftIndex, leftIndexTemp - 1)//继续处理左边的，这里是一个递归的过程
    sort(sortArray, leftIndexTemp + 1, rightIndex)//继续处理右边的 ，这里是一个递归的过程
}

###Java实现：

import java.util.Random;

/**
 * 拿客 www.coderknock.com
 * 三产 创建于 2016年06月23日 23:49:34。
 * 快速排序Java版
 */
public class QuickSort {
    public static void main(String[] args) {
        //要进行排序的数组
        int[] sortArray = new int[10];
        Random ra = new Random();
        //生成随机数，对这个随机数数组进行排序
        System.out.println("随机数组：");
        for (int i = 0; i < sortArray.length; i++) {
            sortArray[i] = ra.nextInt(100);
            System.out.print(sortArray[i] + " ");
        }
        System.out.println();
        sort(sortArray, 0, (sortArray.length - 1));
        System.out.println("排序后的数组：");
        for (int i : sortArray) {
            System.out.print(i + " ");
        }
    }

    public static void sort(int[] sortArray, int leftIndex, int rightIndex) {
        int leftIndexTemp = leftIndex;
        int rightIndexTemp = rightIndex;
        if (leftIndex > rightIndex)
            return;
        //基准数
        int cardinalNum = sortArray[leftIndex];
        while (leftIndexTemp != rightIndexTemp) {
            //顺序很重要，要先从右边开始找
            while (sortArray[rightIndexTemp] >= cardinalNum && leftIndexTemp < rightIndexTemp)
                rightIndexTemp--;
            //再找右边的
            while (sortArray[leftIndexTemp] <= cardinalNum && leftIndexTemp < rightIndexTemp)
                leftIndexTemp++;
            //交换两个数在数组中的位置
            if (leftIndexTemp < rightIndexTemp) {
                sortArray[leftIndexTemp] = sortArray[leftIndexTemp] ^ sortArray[rightIndexTemp];
                sortArray[rightIndexTemp] = sortArray[leftIndexTemp] ^ sortArray[rightIndexTemp];
                sortArray[leftIndexTemp] = sortArray[leftIndexTemp] ^ sortArray[rightIndexTemp];
            }
        }
        sortArray[leftIndex] = sortArray[leftIndexTemp];
        sortArray[leftIndexTemp] = cardinalNum;
        sort(sortArray, leftIndex, leftIndexTemp - 1);//继续处理左边的，这里是一个递归的过程
        sort(sortArray, leftIndexTemp + 1, rightIndex);//继续处理右边的 ，这里是一个递归的过程
    }
}

转载于:https://my.oschina.net/coderknock/blog/702360