【数据结构与算法】快速排序

程序：

package com.nicchagil.generics.study.No099快速排序;

public class QuickSort {
	
    public static void sort(int[] array, int left, int right) {

        if (left > right) {
        	System.out.println("结束递归：[" + left + "], [" + right + "]");
            return;
        }
        print(array, left, right);

        int standardIndex = left;
        int standard = array[standardIndex]; // 起始下标值为标准值
        System.out.println("选取标准值下标：" + standardIndex + "，值为：" + standard);
        int i = left;
        int j = right;

        while (i < j) {
        	/* j从右向左遍历，直到找到比标准值小的值，或者遇到i，就停止 */
            while (array[j] >= standard && i < j) {
                j--;
            }

            /* i从左向右遍历，直到找到比标准值大的值，或者遇到j，就停止 */
            while (array[i] <= standard && i < j) {
                i++;
            }
            
            /*
             * 在此断点，有如下情况：
             * 1、j坐标从右向左找，找到了小于标准值的数；i坐标从左向右找，找到了大于标准值的数
             * 2、j坐标从右向左找，找到了小于标准值的数；i坐标从左向右找，但没找到大于标准值的数，遍历直到与j坐标相等
             * 3、j坐标从右向左找，未能找到小于标准值的数，遍历直到与i坐标相等
             */

            System.out.println("一轮遍历后的下标：[" + i + "]、[" + j + "]，他们的值为：" + array[i] + "、" + array[j]);

            /* i找到了比标准值大的下标、j找到了比标准值小的下标，但它们还没有相遇，就交换它们的值 */
            if (i < j) {
                swap(array, i, j);
            }
            print(array, left, right);
        }

        if (standardIndex != i) {
        	System.out.println("将标准值下标放到i下标，标准值下标和i下标分别为：[" + standardIndex + "], [" + i + "]，它们的值为：" + array[standardIndex] + ", " + array[i]);
        	swap(array, standardIndex, i);
        }
        print(array, left, right);
        
        if (left < i - 1) {
        	System.out.println("递归调用：[" + left + "], [" + (i - 1) + "]");
            sort(array, left, i - 1);
        }

        if (i + 1 < right) {
        	System.out.println("递归调用：[" + (i + 1) + "], [" + right + "]");
            sort(array, i + 1, right);
        }
    }
    
    /**
     * 交换数组指定俩下标的值
     * @param array 数组
     * @param i 下标
     * @param j 下标
     */
    private static void swap(int[] array, int i, int j) {
        System.out.println("交换这两个下标的值：[" + i + "]、[" + j + "], 他们的值为： " + array[i] + "、" + array[j]);
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void main(String[] args) {
    	int[] array = {565,841,496,225,321,586};
        // int[] array = {2,4,6,8,10};
        print(array, 0, array.length - 1);
        sort(array, 0, array.length - 1);
        print(array, 0, array.length - 1);
    }

    /**
     * 打印执行下标范围的数组的值
     * @param array 数组
     * @param i 下标
     * @param j 下标
     */
    public static void print(int[] array, int left, int right) {
        for (int i = left; i <= right; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

}

日志：

565 841 496 225 321 586 
565 841 496 225 321 586 
选取标准值下标：0，值为：565
一轮遍历后的下标：[1]、[4]，他们的值为：841、321
交换这两个下标的值：[1]、[4], 他们的值为： 841、321
565 321 496 225 841 586 
一轮遍历后的下标：[3]、[3]，他们的值为：225、225
565 321 496 225 841 586 
将标准值下标放到i下标，标准值下标和i下标分别为：[0], [3]，它们的值为：565, 225
交换这两个下标的值：[0]、[3], 他们的值为： 565、225
225 321 496 565 841 586 
递归调用：[0], [2]
225 321 496 
选取标准值下标：0，值为：225
一轮遍历后的下标：[0]、[0]，他们的值为：225、225
225 321 496 
225 321 496 
递归调用：[1], [2]
321 496 
选取标准值下标：1，值为：321
一轮遍历后的下标：[1]、[1]，他们的值为：321、321
321 496 
321 496 
递归调用：[4], [5]
841 586 
选取标准值下标：4，值为：841
一轮遍历后的下标：[5]、[5]，他们的值为：586、586
841 586 
将标准值下标放到i下标，标准值下标和i下标分别为：[4], [5]，它们的值为：841, 586
交换这两个下标的值：[4]、[5], 他们的值为： 841、586
586 841 
225 321 496 565 586 841