Java 快速排序

=代码：

package com.vgbh;

public class QuickSorting {

    /* 
     * 快速排序是一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。
     * 
     * 分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。
     * 
     * 利用分治法可将快速排序的分为三步： 在数据集之中，选择一个元素作为”基准”（pivot）。
     * 所有小于”基准”的元素，都移到”基准”的左边；所有大于”基准”的元素，都移到”基准”的右边。 这个操作称为分区 (partition)
     * 操作，分区操作结束后，基准元素所处的位置就是最终排序后它的位置。
     * 对”基准”左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。
     */

    private static int n = 10;//数组长度
    private static int[] arr = new int[10];//数组

    static PublicOut pc = null;//外部对象

    public static void main(String[] args) {
        pc = new PublicOut();

        System.out.println("排序前：");
        pc.data(arr, n);
        pc.prin(arr, n);

        QuickSorting qs = new QuickSorting();
        qs.quick(arr, 0,9);

        System.out.println("排序后：");
        pc.prin(arr, n);

    }

    public void quick (int[] arr,int left,int right) {
        if (arr.length > 0) {
            if (left < right) {
                int pivotpos = partition(arr,left,right);
                quick(arr,left,pivotpos-1);
                quick(arr,pivotpos+1,right);
            }
        }

    }

    public int partition (int[] arr,int left,int right) {
        //返回最后定位基准的下标

        int temp = arr[left];
        while (left < right) {
            while (left<right && arr[right]>=temp) {
                --right;
                //System.out.println("右移一次");
            }
            arr[left] = arr[right];
            //System.out.println("右边的支付给左边");
            while (left<right && arr[left]<=temp) {
                ++left;
                //System.out.println("左移一次");
            }
            arr[right] = arr[left];
            //System.out.println("左边的值赋给右边");
        }
        arr[left] = temp;
        //System.out.println(left);
        //pc.prin(arr, n);

        return left;

        /* 一次错误的示范
        int pivot = arr[l];
        while (l < r) {
            while (l<r && arr[l]<=pivot) {
                r--;
                if (l<r) {
                    arr[l] = arr[r];
                }
            }
            while (l<r && arr[r]>=pivot) {
                l++;
                if (l<r) {
                    arr[r] = arr[l];
                }
            }
        }
        arr[l] = pivot;
        return l;
         */
    }

    /*
    对于1~10的有规律排序，快速排序可以进行排序。
    但对于不规则排序会死循环，会一直在赋值之间来回赋值，从而进入死循环。
     */

}

这个快速排序还有一点问题，问题在代码中有阐述，下来我会再思考一下的。

有问题可以联系我的邮箱。

——————————–分割线

考试终于完了，端午没回家，那就来搞一下快速排序吧，

我终于发现了问题：
left- - 和 - -left
right++ 和 ++right
这四个是不一样的，后边会出一期博客详细解释。

感谢各位大佬对我的包容，好好写博客，有问题可以给我发邮件。