一个例子搞懂快速排序算法

一、快速排序算法

快速排序算法是对冒泡排序的一种改进。
快排基本思想是：通过一趟排序将要排序的数据以基准数据分割成独立的两部分，其中一部分的所有数据都比基准数据小，另外一部分的所有数据都比基准数据大，然后再通过递归对这两部分数据分别进行快速排序，实现整个数据变成有序序列。

二、实例排序步骤分析

样本数据：45 23 68 88 55 12 100 9

• 基准数： 一般取待排序序列的第一个
• 目标： 交换后， 基准数左边的数要全部小于基准数， 其右边的数要全部大于基准数
  步骤如下：
• 第一次排序基准数：45
• 从后往前找到比基准数小的数进行对换，循环找到9小于45，则9和45对换位置，否则右边下标前移，继续循环判断 <-----
  9 23 68 88 55 12 100 45
• 从前往后找到比基准数大的进行对换，23小于45，左边下标后移，继续循环找到68大于45，则68和45对换位置，否则左边下标后移，继续循环判断 ----->
  9 23 45 88 55 12 100 68
• 从后往前找到比基准数小的数进行对换 <-----
  9 23 12 88 55 45 100 68
• 从前往后找到比基准数大的进行对换 ----->
  9 23 12 45 55 88 100 68
• 至此，以基准数分为3部分，左边的都比其小，右边的都比其大，第一次以45为基准数的排序完成
  {9 23 12} {45} {55 88 100 68}

对于{9 23 12} 和 {55 88 100 68}这两部分数据再通过递归分别进行快速排序。

三、算法实现

实现代码如下：

/**
 * 快速排序算法
 */
public class QuickSort {
    public static void main(String[] args) {
        int data[] = {45,23,68,88,55,12,100,9};
        quickSort(data, 0, data.length-1);
    }

    private static void quickSort(int[] data, int left, int right){
        int base = data[left];
        int leftIndex = left; // 记录当前左边要找的位置
        int rightIndex = right; // 记录当前右边要找的位置
        while(leftIndex < rightIndex){
            // 从队列后面往前找出比base小的第一个数， 没有满足条件的则右边下标前移，继续判断
            while(leftIndex < rightIndex && data[rightIndex]>=base){
                rightIndex --;
            }
            // 表示已找到 9
            if (leftIndex < rightIndex){
                swap(data, leftIndex, rightIndex);
                leftIndex ++;
                print(data);
            }
            // 从队列前面往后找出比base 大的第一个数
            while (leftIndex < rightIndex && data[leftIndex] <= base) {
                leftIndex++;
            }
            // 循环2次后，表示已找到 68
            if(leftIndex < rightIndex){
                swap(data, leftIndex, rightIndex);
                rightIndex --;
                print(data);
            }
        }
        // print(data);
        // 以基准数分为3部分, 前后部分递归排序
        if(leftIndex > left){
            quickSort(data, left, leftIndex-1);
        }

        if(rightIndex < right){
            quickSort(data, leftIndex+1, right);
        }
    }

    /**
     * 对换数据位置
     * @param data
     * @param leftIndex
     * @param rightIndex
     */
    private static void swap(int[] data, int leftIndex, int rightIndex) {
        int temp = data[rightIndex];
        data[rightIndex] = data[leftIndex];
        data[leftIndex] = temp;
    }

    private static void print(int[] data){
        for(int i=0,len = data.length; i<len; i++){
            System.out.print(data[i]+" ");
        }
        System.out.println();
    }

}

运行结果：

9 23 68 88 55 12 100 45 
9 23 45 88 55 12 100 68 
9 23 12 88 55 45 100 68 
9 23 12 45 55 88 100 68 
9 12 23 45 55 88 100 68 
9 12 23 45 55 68 100 88 
9 12 23 45 55 68 88 100 

注： 快速排序的最好的情况（每次数据划分得很均匀）时间复杂度为O（nlogn），最坏的情况（需排序的数据为正序或逆序排列时）复杂度为O（n^2）。

---

参考：