数据结构与算法之高级排序(快速/归并)<十二>

基础排序–>数据结构与算法之基础排序(冒泡/插入/选择)<十>

希尔和堆排序–>数据结构与算法之高级排序(希尔/堆)<十一>

快速排序

快速排序是一个非常著名的算法 是分治算法的实例之一 也是十分常用算法
优点 
    尽管最坏情况下的复杂度为O(N^2) 但是平均复杂度为O(nlogn) 并且在大多数计算机上的运行效率很好
缺点
    稳定性未知 取决于如何处理枢轴
算法
    如果序列只有一个元素 返回
    选择序列中的一个元素作为枢轴点
    序列被枢轴分为两部分 一部分大于枢轴 另一部分小于枢轴
    对着两部分递归调用该方法

归并排序

归并排序是分治算法的实例之一 
归并是将两个已排序的文件合成一个更大的已排序文件的过程
选择是吧文件分成包含k个最小元素和n-k个最大元素的过程
选择和归并互为逆操作
归并排序是快速排序的补充是稳定的算法

以下算法实现仅供参考若有错误欢迎指正

快速排序

// 输入待排序数组 排序区域
    public void KQuickSort(int[] arr, int start, int end) {
        if (end > start) {
            // 获取枢轴
            int pivot = getPivot(arr, start, end);
            // 递归调用
            KQuickSort(arr, start, (pivot - 1));
            KQuickSort(arr, (pivot + 1), end);
        }
    }

    // 获取枢轴
    private int getPivot(int[] arr2, int start, int end) {
        int left = start;
        int right = end;
        // 选定枢轴
        int keyWord = arr2[start];
        // 将枢轴两边排序 保证 左边的小于枢轴右边的大于枢轴
        while (left < right) {
            // 当右边的大于枢轴
            while (left < right && arr2[right] > keyWord)
                right--;
            // 找到右边小于枢轴的点或者找到了最右边
            if (left < right) {
                arr2[left] = arr2[right];
                left++;
            }
            // 左边的小于于枢轴
            while (left < right && arr2[left] < keyWord)
                left++;
            // 左边大于枢轴的点找到了或者找到了最左边
            if (left < right) {
                arr2[right] = arr2[left];
                right--;
            }
        }
        arr2[right] = keyWord;
        return right;
    }

归并排序

    // 归并排序
    public int[] mergeSort(int[] array, int[] array1, int left, int right) {
        // 中间点
        int mid;
        // 递归出口
        if (right > left) {
            mid = (right + left) / 2;
            // 左边分割
            mergeSort(array, array1, left, mid);
            // 右边分割
            mergeSort(array, array1, mid + 1, right);
            // 分割到最小后合并
            Merge(array, array1, mid + 1, left, right);
        }
        return array;
    }

    // 合并两已排序数组成为一个已排序数组
    private void Merge(int[] array, int[] temp, int mid, int left, int right) {
        // 左边数组结束位置
        int left_end;
        if (mid == 0)
            left_end = mid;
        else
            left_end = mid - 1;
        // 计数器
        int temp_pos = left;
        int size = right - left + 1;
        // 两个数组都没有遍历
        // 若有一个数组遍历完成则将另一个数组计数器后面的数据加入合并的数组
        while ((left <= left_end) && (mid <= right)) {
            // 两个数组(这两个数组是已排序)中的最小值比较
            // 如果array的最小值比array1的最小值还要小
            if (array[left] <= array[mid]) {
                temp[temp_pos] = array[left];
                temp_pos++;
                left++;
            } else {
                temp[temp_pos] = array[mid];
                temp_pos++;
                mid++;
            }
        }
        // 如果左边的数组遍历完成
        while (mid <= right) {
            temp[temp_pos] = array[mid];
            temp_pos++;
            mid++;
        }
        // 如果右边数组遍历完成
        while (left <= left_end) {
            temp[temp_pos] = array[left];
            temp_pos++;
            left++;
        }
        // 将temp已排序数组复制到array数组
        for (int i = 0; i < size; i++) {
            array[right] = temp[right];
            right--;
        }
    }

主要的排序算法到此差不多到一段落