快速排序,归并排序,二分查找

目录

一、快速排序（用得最多）

•  快速排序
• 应用场景
• 缺点
• 算法思路
• 代码实现
• 时间复杂度

二、归并排序

• 归并排序
• 应用场景
• 缺点
• 算法思路
• 代码实现
• 时间复杂度

三、二分查找

• 二分查找
• 算法思路
• 代码实现
• 时间复杂度

---

一、快速排序（用得最多）

快速排序  

       快速排序（Quicksort）是对冒泡排序的一种改进。 

        快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

应用场景

•         数据量大并且是线性结构。

 缺点

•        有大量重复数据的时候，性能不好     
•       单向链式结构处理性能不好（链式不建议不使用）

 算法思路
  有一个游标Low和游标High，分别指向第一个元素和最后一个元素，先取一个Mid_value = 第一个值，然后Low指向的数据和Mid_value比较一下，如果Low < Mid_value, 那么Low +=1 ， 因为小的值是排在左边的，否则，Low不动，High指向的数据和Mid_value比较一下，如果High < Mid_value， 那么High -= 1, 因为大的值是排在右边的。当High和Low重合的时候，则停止，把Mid_value的值放到这里来。然后，达到目标：Mid_value左边的值都比Mid_value小，右边的值都比Mid_value大，然后对于左边和右边，继续做一样的操作，直到左边/右边只剩下一个数，就停止（递归方式）
 代码实现：

  /**
     * 二叉树快速排序
     * quick sort ,this is  out of order
     *  其实就是中序的排法
     * @param array
     * @param begin 开始
     * @param end   结束
     */
    public static void quickSortArray(int[] array, int begin, int end) {
        if (end - begin <= 0) return;
        int x = array[begin];
        int low = begin;
        int high = end;
        /**由于会从两头取数据，设置一个方向的标识位**/
        boolean direction = true;
        L:/**标签，跳出这个循环的位**/
        while (low < high) {
            /**从左往右找**/
            if (direction) {
                for (int i = high; i > low; i--) {
                    if (array[i] <= x) {
                        array[low++] = array[i];
                        high = i;
                        direction = !direction;
                        continue L;
                    }
                }
                /**上面条件不成立，说明指针重合了**/
                high = low;
            } else {
                for (int i = low; i < high; i++) {
                    if (array[i] >= x) {
                        array[high--] = array[i];
                        low = i;
                        direction = !direction;
                        continue L;
                    }
                }
                /**上面条件不成立，说明指针重合了**/
                low = high;
            }
        }
        /**把最后找到的值 放入中间位置
         开始完成左右两边的操作**/
        array[low] = x;
        quickSortArray(array, begin, low - 1);
        quickSortArray(array, low + 1, end);
    }

    时间复杂度

•  最优时间复杂度：O(nlogn) 
•  最坏时间复杂度：O(n^2) 
•  稳定性：不稳定

二、归并排序

归并排序

  归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序是一种稳定的排序方法。
  应用场景

•       数据量大并且有很多重复数据，链式结构

  缺点

•       需要空间足够大

算法思路：
  拿上面例子举例，先对半分，每组再对半分，每组再对半分，直到分成每组只有一个值为止。然后开始归并，就是同样的过程反过来来一遍：组成两个为一组，组成四个为一组

  归并的时候有两个游标，一个left，一个right, left指的值和right指的值比较
代码实现

 /**
     * 归并排序
     * 后序
     * @param array
     * @param left
     * @param right
     */
    public static void mergeSort(int array[], int left, int right) {
        if (left == right) {
            return;
        } else {
            int mid = (left + right) / 2;
            /**相当于后序排序 LRD
             * 最底层拆分对比
             *    左边到中间->中间到右边->归并
             * **/
            mergeSort(array, left, mid);
            mergeSort(array, mid + 1, right);
            merge(array, left, mid + 1, right);
        }
    }
 
    /***
     *   array  归并
     * @param array
     * @param left
     * @param mid
     * @param right
     */
    public static void merge(int[] array, int left, int mid, int right) {
        int leftSize = mid - left;
        int rightSize = right - mid + 1;
        /**拆分两个数组，填充数据，下标以index开始**/
        int[] leftArray = new int[leftSize];
        int[] rightArray = new int[rightSize];
 
        for (int i = left; i < mid; i++) {
            leftArray[i - left] = array[i];
        }
        for (int i = mid; i <= right; i++) {
            rightArray[i - mid] = array[i];
        }
        /**合并的操作**/
        int i = 0;
        int j = 0;
        int k = left;
        while (i < leftSize && j < rightSize) {
            if (leftArray[i] < rightArray[j]) {
                array[k] = leftArray[i];
                k++;
                i++;
            } else {
                array[k] = rightArray[j];
                k++;
                j++;
            }
        }
        /**如果左边还有剩下的，直接cpoy**/
        while (i < leftSize) {
            array[k] = leftArray[i];
            k++;
            i++;
        }
        /**如果右边还有剩下的，直接cpoy**/
        while (j < rightSize) {
            array[k] = rightArray[j];
            k++;
            j++;
        }
    }

时间复杂度

•   最优时间复杂度：O(nlogn)
•   最坏时间复杂度：O(nlogn)
•   稳定性：稳定

三、二分查找

二分查找

二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

 算法思路

  必须遵循两个条件：数组有序、符合左闭右开原则(是一种区间无重复的思想)

 代码实现

 /***
     *  二分查找
     *  binary search ,this  is  must be  order  array
     * @param array  源数组
     * @param fromIndex  开始索引
     * @param toIndex  结束索引
     * @param key  值
     * @return
     */
    public static int binarySearch(int[] array, int fromIndex, int toIndex, int key) {
        int low = fromIndex;
        /**左开右闭原则,保持连续空间**/
        int high = toIndex - 1;
        while (low <= high) {
            /**查找中间的数**/
            int midIndex = (low + high) >> 1;
            int midValue = array[midIndex];
            /**如果大于中间数，左边查找**/
            if (key > midValue) {
                low = midIndex + 1;
                /**如果小于中间数，右边查找**/
            } else if (key < midValue) {
                high = midIndex - 1;
            } else {
                return midIndex;
            }
        }
        /**low+1表示找不到时停在了第low+1个元素的位置**/
        return -(low + 1);
    }

时间复杂度

•   最优时间复杂度：O(1)
•   最坏时间复杂度：O(logn)