数据结构之快速排序

//实现快速排序：

public class Quick_Sort {

    //设置阈值，当排序的元素小于这个阈值的时候，采用直接插入排序
    private static int cutOff = 2;  //设置元素个数，进行切换排序
    //对外提供的接口
    public static void quick_Sort(int arr[], int n) {
        quick_Sort(arr, 0, n - 1);
    }

    //内部实现排序
    private static void quick_Sort(int arr[], int left, int right) {

if (cutOff <= right - left) {  //元素个数大于阈值时候，进行快速排序
            // 使用快速排序
        int pivot = median(arr, left, right);  //获取中间位置元素
        int i = left;
        int j = right - 1;
        for (;;) {
    while (arr[++i] < pivot) {  //从左到右寻找大于pivot的元素位置
                }
    while (arr[--j] > pivot) { //从右到左寻找小于pivot的元素位置

                }
                if (i < j) {  //进行元素交换
                    swap(arr, i, j);
                } else {  //没有这样的元素对，结束循环
                    break;
                }
            }
            swap(arr, i, right - 1);  
            quick_Sort(arr, left, i - 1);  //进行左边分组递归
            quick_Sort(arr, i + 1, right); //进行右边分组递归
        } else {
            // 使用直接插入排序
            insert_Sort(arr, left, right - left + 1);
        }
    }

public static void insert_Sort(int arr[], int start, int n) {

        for (int i = start + 1; i <= n + start - 1; i++) {
            int j = i - 1;
            int tmp = arr[i];
            while (j >= start && arr[j] > tmp) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = tmp;
        }
    }

    private static int median(int arr[], int left, int right) {
        int mid = (left + right) >> 1;
        // 获取中间的位置
        if (arr[left] > arr[mid]) {
            swap(arr, left, mid);
        }
        if (arr[left] > arr[right]) {
            swap(arr, left, right);
        }
        if (arr[mid] > arr[right]) {
            swap(arr, mid, right);
        }
        swap(arr, mid, right - 1);
        return arr[right - 1];
    }

    private static void swap(int arr[], int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}