快速排序算法

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

/** * 快速排序(递归) */
public static void quickSort(int[] arr,int start,int end) {
        int avg = arr[start];
        int i=start,j=end;
        boolean b = false;
        while(j>i) {
            if(arr[i] > avg || arr[j] < avg) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                b = !b;
            }
            
            if(b) i++; else j--;
        }
        
        if(start < i-1) quickSort(arr,start,i-1);
        if(end > i+1) quickSort(arr,i+1,end);
    }
    
    /**
     * 快速排序(非递归)
     */
    public static void quickSortNonRecursive(int[] arr) {
        //Queue<Integer> queue = new ArrayDeque<>();
        Queue<Integer> queue = new ArrayDeque<>();
        queue.add(0);
        queue.add(arr.length-1);
        
        while(!queue.isEmpty()) {
            int start = queue.poll();
            int end = queue.poll();
            int i = start;
            int j = end;
            int avg = arr[start];
            boolean b = false;
            while(j>i) {
                if(arr[i] > avg || arr[j] < avg) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                    b = !b;
                }
                if(b) i++; else j--;
            }
            if(start < i-1) {
                queue.add(start);
                queue.add(i-1);
            }
            if(end > i+1) {
                queue.add(i+1);
                queue.add(end);
            }
        }
    }
    
    /**
     * 快速排序（多线程）
     * @author 无所事事
     *
     */
    static class SortTask extends RecursiveAction {
        int[] arr;
        int start;
        int end;
        
        public SortTask(int[] arr, int start, int end) {
            super();
            this.arr = arr;
            this.start = start;
            this.end = end;
        }

        @Override
        protected void compute() {
            int avg = arr[start];
            int i=start,j=end;
            boolean b = false;
            while(j>i) {
                if(arr[i] > avg || arr[j] < avg) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                    b = !b;
                }
                
                if(b) i++; else j--;
            }
            
            if(start < i-1) {
                SortTask task = new SortTask(arr,start,i-1);
                task.fork();
            }
            if(end > i+1) {
                SortTask task = new SortTask(arr,i+1,end);
                task.fork();
            }
        }
        
    }

这里使用了3种方式实现

第一种是最常见的使用递归的方式来实现，使用递归最大的问题就是可能会造成栈溢出，如果是在小规模的排序时，使用此方式是速度最快效率最高的，因为java线程本身的栈，优化程度相当高，而且相比于第二种方式，不需要有自动装箱拆箱的操作，也可以节省一大笔开销。优先推荐使用此方式

第二种方式是将第一种方式利用队列改写成的非递归算法，此方式不会有栈溢出的问题，但是由于不同的队列实现，以及自动装箱拆箱的操作影响，速度不及第一种方式，在大规模的排序时速度也不如第三种方式

第三种方式利用java的fork/join框架来实现快速排序，由于是多线程同时处理，所以速度要比第二种要快，在小规模的排序时不如第一种实现方式。使用此方式时最好与其他排序算法同时使用，不要把任务分的太细，避免形成过多的线程。