技術標籤：演算法打卡演算法排序演算法

歸併排序是典型的的分治思想的體現,關鍵在與遞迴的分和遞迴的和.最好結合動態檢視學習.

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;
    }
}