LeetCode打卡1.26---归并排序

归并排序是典型的的分治思想的体现,关键在与递归的分和递归的和.最好结合动态视图学习.

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {1, 3, 6, 4, 2, 66, 23};
        //递归算法 肯定是要有左右边界的
        MergeSort ms = new MergeSort();
        int[] temp = new int[arr.length];
        //temp数组的目的在于减少额外的空间复杂度
        ms.mergeSort(arr, 0, arr.length - 1, temp);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 分治算法: 把一个大问题分解成子问题,递归的解决
     *
     * @param arr
     * @param left
     * @param right
     * @param temp
     */
    private void mergeSort(int[] arr, int left, int right, int[] temp) {
        //递归的终止条件
        if (left >= right) return;
        //防止整型溢出
        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid, temp);
        mergeSort(arr, mid + 1, right, temp);
        merge(arr, left, mid, right, temp);
    }

    private void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left, j = mid + 1;
        int t = 0;
        //对于"=" 的加与不加, 视情况而定, 可以使用特例进行判断
        while (i <= mid && j <= right) {
            if (arr[i] < arr[j]) {
                temp[t++] = arr[i++];
            } else {
                temp[t++] = arr[j++];
            }
        }
        //现在将未进行排序继续在临时数组中进行排序,并copy给原来的数组
        while (i <= mid) {
            temp[t++] = arr[i++];
        }
        while (j <= right) {
            temp[t++] = arr[j++];
        }
        int m = 0;
        while (left <= right) {
            arr[left++] = temp[m++];
        }
    }
}

/**
 * @description:插入排序:基础排序算法中较重要的排序算法
 * @author: Tian
 * @time: 2021/1/26 21:35
 */

public class InsertSort {

    public static void main(String[] args) {

        InsertSort insertSort = new InsertSort();
        int[] nums = {5, 5, 4, 1, 7, 5, 9, 3, 58};
        int[] ints = insertSort.insertSort(nums);
        System.out.println(Arrays.toString(ints));
    }


    public int[] insertSort(int[] nums) {
        for (int i = 1; i < nums.length; i++) {
            int j = i;
            int temp = nums[j];
            while (j > 0 && nums[j - 1] < temp) {
                //赋值
                nums[j] = nums[j - 1];
                j--;
            }
            if (j != i) {
                //说明已经进行插入了
                nums[j] = temp;
            }
        }
        return nums;
    }
}

/**
 * @description: 二分查找,关键在于注意等号是否成立
 * @author: Tian
 * @time: 2021/1/26 22:43
 */

public class BinarySearch {

    /***
     * 查找的数组为有序数组
     * @param array
     * @param target
     * @return
     */
    public int binarySearch(int[] array, int target) {
        int left = 0, right = array.length - 1, mid;
        //等号的存在可以让我们查到所有的元素
        while (left <= right) {
            mid = left + (right - left) / 2;
            if (array[mid] == target) {
                return mid;
            } else if (array[mid] < target) {
                left = mid + 1;
            } else {
                right = mid -1 ;
            }
        }
        return -1;
    }
}