快速排序算法

• 快速排序
• • 原理
  • API设计
  • 代码
  • 效率对比

• 排序原理：
  1. 首先设定一个分界值，通过该分界值将数组分成左右两部分；
  2. 将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值；
  3. 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
  4. 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。
     

package sort.paixu;



public class Quick {

    public static void sort(Comparable[] a){
        int lo = 0;
        int hi = a.length-1;
        sort(a,lo,hi);
    }

    
    private static void sort(Comparable[] a,int lo,int hi){
        // 安全性校验
        if(hi<=lo){
            return;
        }
        // 需要对数组中lo索引到hi索引处进行分组（左子组 右子组）
        int partition = partition(a, lo, hi); // 返回分组分界值所在索引，分界值位置变化后的索引
        // 让左子组有序
        sort(a,lo,partition-1);
        // 让右子组有序
        sort(a,partition+1,hi);
    }

    public static  int partition(Comparable[] a,int lo,int hi){
       // 分界值
        Comparable key = a[lo];
        // 定义两指针
        int left = lo;
        int right = hi+1;
        // 切分
        while (true){
            // 先从右往左扫描，移动到right指针，找到一个比分界值值小的元素，停止
            while (less(key,a[--right])){
                // 判断
                if(right == lo){
                    break;
                }
            }
            // 再从左往右扫描，移动到left指针，找到一个比分界值值大的元素，停止
            while (less(a[++left],key)){
                // 判断是否一直到最后一个元素还是没搜索到一个qing'kuan'b'g
                if(left == hi){
                    break;
                }
            }
            // 判断left是不是大于等于right，是否结束循环
            if(left >= right){
                break;
            }else {
                exch(a,left,right);
            }
        }
        // 交换分界值和两个指针相遇的值
        exch(a,lo,right);
        return right;
    }

    
    private static void merge(Comparable[] a,int lo,int mid,int hi){
        // 定义三个指针
        int i = lo;
        int p1 = lo;
        int p2 = mid+1;
    }

    private static Boolean less(Comparable a,Comparable b){
        return a.compareTo(b) < 0;
    }

    private static void exch(Comparable[] o,int a,int b){
        Comparable temp;
        temp = o[a];
        o[a] = o[b];
        o[b] = temp;
    }
}

• 测试

public class QuickTest {
    public static void main(String[] args) {
        Integer[] o = {1,5,3,6,2,8,4,7,9};
        Quick.sort(o);
        System.out.println(Arrays.toString(o));
    }
}

• 快速排序时间复杂度分析：

  1. 快速排序的一次切分从两头开始交替搜索，直到left和right重合，因此，一次切分算法的时间复杂度为O(n),但整个快速排序的时间复杂度和切分的次数相关。

  2. 最优情况：每一次切分选择的基准数字刚好将当前序列等分。如果我们把数组的切分看做是一个树，那么上图就是它的最优情况的图示，共切分了logn次，所以，最优情况下快速排序的时间复杂度为O(nlogn);
     
  3. 最坏情况：每一次切分选择的基准数字是当前序列中最大数或者最小数，这使得每次切分都会有一个子组，那么总共就得切分n次，所以，最坏情况下，快速排序的时间复杂度为O(n^2);