排序之冒泡排序、快速排序、归并排序、堆排序、二分查找

package test;

import org.junit.Test;

/**
 * @PackageName:test
 * @ClassName:Test2
 * @Description:
 * @Author: ZQ
 * @Date:2019/08/19 10:21
 */
public class Test2 {

    /**
     * 快排排序：指定一个位置，将比该值小的划分到左边，大的划分到右边，退出后将该值划分到中间
     * 时间复杂度最好为O(nlogn)，最坏为O(n^2)
     * 最优的情况下空间复杂度为：O(logn) 每一次都平分数组的情况
     * 最差的情况下空间复杂度为：O( n )  退化为冒泡排序的情况
     *
     * @param num   需要排序数组
     * @param start 开始位置
     * @param end   结束位置
     */
    public void kuaipai(int[] num, int start, int end) {
        //定义
        if (start > end) return;
        int i = start;
        int j = end;
        int k = num[start];

        while (i < j) {

            while (i < j && num[j] > k) j--;
            while (i < j && num[i] <= k) i++;

            if (i < j) {
                int temp = num[i];
                num[i] = num[j];
                num[j] = temp;
            }
        }

        int temp = num[i];
        num[i] = num[start];
        num[start] = temp;

        kuaipai(num, start, i - 1);
        kuaipai(num, i + 1, end);

    }

    /**
     * 冒泡算法：将比当前值大的值往外运
     * 时间复杂度：O(n^2) 空间复杂度为O(1)
     *
     * @param num
     */
    public void maopao(int[] num) {
        if (num == null || num.length == 1) return;
        for (int i = 0; i < num.length - 1; i++) {
            for (int j = 0; j < num.length - i - 1; j++) {
                if (num[j] > num[j + 1]) {
                    int temp = num[j];
                    num[j] = num[j + 1];
                    num[j + 1] = temp;
                }
            }
        }
    }

    /**
     * 归并排序：把长度为n的输入序列分成两个长度为n/2的子序列
     * 对这两个子序列分别采用归并排序
     * 将两个排序好的子序列合并成一个最终的排序序列
     * 

     * 时间复杂度：均为O(nlogn)  空间复杂度：O(n)
     *
     * @param arr
     * @param start
     * @param end
     */
    public void mergeSort(int[] arr, int start, int end) {
        //递归结束点
        if (arr == null || start >= end) return;
        int mid = (start + end) / 2;
        //将左边进行拆分
        mergeSort(arr, start, mid);
        //将右边进行拆分
        mergeSort(arr, mid + 1, end);
        //将整个拆分的结果进行合并
        merge(arr, start, mid, end);
    }

    private void merge(int[] arr, int start, int mid, int end) {

        //定义一个临时数组来存储最小值
        int[] array = new int[arr.length];
        int i = start;
        int j = mid + 1;
        //临时数组索引
        int k = start;

        //取出最小值到临时数组
        while (i <= mid && j <= end) {
            array[k++] = arr[i] > arr[j] ? arr[j++] : arr[i++];
        }

        //将不为空的段序列加入到临时数组末尾
        while (i <= mid) {
            array[k++] = arr[i++];
        }
        while (j <= end) {
            array[k++] = arr[j++];
        }

        //将临时数组的值复制到原数组上
        for (int m = start; m <= end; m++) {
            arr[m] = array[m];
        }
    }

    /**
     * 堆排序：父节点的键值大于子节点
     * 构建大根堆：将array看成完全二叉树的顺序存储结构
     * 

     * 时间复杂度：O(nlogn)  空间复杂度：O(1)
     *
     * @param arr
     */
    public void HeadSort(int[] arr) {

        //从最后一个节点的父节点开始，直到根节点为0，反复调整堆
        for (int i = (arr.length) / 2 - 1; i >= 0; i--) {
            adjustAddr(arr, arr.length, i);
        }

        //排序，将最大的节点放到堆尾，然后从根节点开始调整
        for (int j = arr.length - 1; j >= 1; j--) {
            int temp = arr[0];
            arr[0] = arr[j];
            arr[j] = temp;
            adjustAddr(arr, j, 0);
        }
    }

    private void adjustAddr(int[] arr, int length, int i) {

        int k = i, temp = arr[i], index = 2 * k + 1;
        while (index < length) {
            if (index + 1 < length) {
                if (arr[index] < arr[index + 1]) {
                    index += 1;
                }
            }
            if (arr[index] > temp) {
                arr[k] = arr[index];
                k = index;
                index = 2 * k + 1;
            } else {
                break;
            }
        }
        arr[k] = temp;
    }


    /**
     * 二分查找非递归方法
     * @param a 数组
     * @param toFind 查询值
     * @param low   起始角标
     * @param high  尾角标
     * @return
     */
    public int binarySearch(int[] a, int toFind, int low, int high) {
        if (low > high || toFind < a[low] || toFind > a[high]) {
            return -1;
        }
        int mid;
        while (low <= high) {
            mid = (low + high) / 2;
            if (toFind == a[mid]) {
                return mid;
            } else if (toFind < a[mid]) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return -1;
    }

    /**
     * 二分查找递归方式
     * @param a 
     * @param toFind
     * @param low
     * @param high
     * @return
     */
    public int binarySearch1(int[] a, int toFind, int low, int high) {
        if (low > high || toFind < a[low] || toFind > a[high]) {
            return -1;
        }
        int mid = (low + high) / 2;
        if (toFind == a[mid]) {
            return mid;
        } else if (toFind < a[mid]) {
            return binarySearch1(a, toFind, low, mid - 1);
        } else {
            return binarySearch1(a, toFind, mid + 1, high);
        }
    }


    @Test
    public void test() {
        int[] num = {23, 58, 79, 36, 25, 87, 15, 63};
        //kuaipai(num,0,num.length-1);
        //maopao(num);
        //mergeSort(num,0,num.length-1);
        //HeadSort(num);
        for (int i : num) {
            //System.out.print(i + "  ");
        }

        int[] a = {1, 3, 4, 6, 8, 9, 13, 21};
        System.out.println(binarySearch(a, 8, 0, 7));
        System.out.println(binarySearch1(a, 66, 0, 7));

    }

}