快速排序

快速排序跟冒泡排序都是交换排序方法，但不同的是快速排序速度非常快，它的实现思路是这样的，从带排序的数据序列中任取一个数据作为分界值，比它小的数据元素放在左边，比他大的元素放在右边。经过一趟下来之后就形成了左右两个子序列，左边元素值比分界值小，右边元素值比分界值大，接下来对左右两个子序列进行递归，对两个子序列重新选择中心元素并按照此规则进行调整。

在李刚写的一本书上是这样描述这个过程的，我觉得非常清楚，所以给大家分享一下，

1.选出指定的分界值。

2.将所有比分界值小的元素放在元素左边。

3.将所有比分界值大的元素 放在右边。

现在问题是怎么是实现第二步和第三步。过程如下

1.定义一个变量i，i变量从左边第一个索引开始，找大于分界值元素的索引，并用i来记录他。

2.定义一个变量j，变量j从右边第一个索引开始，找到小于分界值元素的索引。并用j记录它。

3.如果i<j则交换两个索引处的元素。

下面是实现过程

package com.demo;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * Created by wk on 2014/6/26.
 */
public class QuickSort {

    //插入排序
    public static void main(String args[]) {
        int[] older_arr = getArray(10);
        System.out.println("未排序：");
        display(older_arr);
        int[] new_arr = quickSort(older_arr, 0, older_arr.length - 1);
        System.out.println("排序后：");
        display(new_arr);

    }

    static int[] quickSort(int[] sorts, int start, int end) {
        //将左边的第一个值作为分界值
        if (start < end) {
            int base = 0;
            base = sorts[start];
            //从左边开始搜索大于分界值的元素索引
            int i = start;
            //从右边开始搜索，搜索小于分界值的索引
            int j = end + 1;
            while (true) {
                while (i < end && sorts[++i] >= base) ;
                while (j > start && sorts[--j] <= base) ;
                if (j > i) {
                    int tem = sorts[i];
                    sorts[i] = sorts[j];
                    sorts[j] = tem;
                } else {
                    break;
                }

            }
            int tem = sorts[start];
            sorts[start] = sorts[j];
            sorts[j] = tem;
            //递归左集合
            quickSort(sorts, start, j - 1);
            //遍历右集合
            quickSort(sorts, j + 1, end);
        }

        return sorts;
    }

    public static void display(int[] arrays) {
        for (Integer i : arrays)
            System.out.print(i + ",");
    }

    //获取不重复随机数
    public static int[] getArray(int n) {
        List<Integer> list = new ArrayList<Integer>();
        int[] ins = new int[n];

        for (int i = 0; i < n; i++) {
            int number = new Random().nextInt(1000);
            if (!list.contains(number)) {
                list.add(number);
                ins[i] = number;

            }
        }
        return ins;
    }
}

快速排序是排序里面速度最快的，但也是最不好理解的，涉及到了分治法和递归的思想。 　 在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n²)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来，且在大部分真实世界的数据，可以决定设计的选择，减少所需时间的二次方项之可能性。

帮助理解下这是快排的一个动画