算法图解笔记

算法图解–java 实现笔记
1.二分法查找

//二分法查找
    public static int binarySearch(int[] nums,int item) {
        int low = 0;
        int high = nums.length - 1;
        while (low <= high){
            int mid = (low+high) / 2;
            System.out.println("mid:"+mid);
            int guess = nums[mid];
            if(guess == item){
                return mid;
            }else if(guess > item){
                high = mid -1;
            }else{
                low = mid + 1;
            }
        }
        return -1;
    }

第四章：练习题
4.1 sum函数代码

/*
     * 基线条件：最简单的数组不包含元素
     * 递归条件：让数组越来越短 -- 即数组开始下标往后一直移动
     *
     */
    public static int sum(int[] nums,int i){
        if(nums.length == 0){
            return 0;
        }
        if(i == nums.length - 1){
            return nums[i];
        }
        return nums[i] + sum(nums,i+1);
    }

4.2 列表元素数量

/*
     * 计算列表元素数量
     * 基线条件：空数组元素为0
     * 递归条件：让数组越来越短 -- 即数组开始下标往后一直移动
     *
     */
    public static int countArr(int[] nums,int i){
        if(nums.length == 0){
            return 0;
        }
        if(i == nums.length - 1){
            return 1;
        }
        return 1 + countArr(nums,i+1);
    }

4.3 计算最大值

/*
     * 列表中最大数字
     * 基线条件：数组只有一个元素 即为最大
     * 递归条件：让数组越来越短 -- 即数组开始下标往后一直移动
     *
     */
    public static int maxArr(int[] nums,int i){
        if(nums.length == 0){
            return 0;
        }
        if(i == nums.length - 1){
            return nums[i];
        }
        int i1 = maxArr(nums, i + 1);
        return Math.max(nums[i], i1);
    }

4.4

 /*
     * 二分查找递归实现
     * 基线条件：数组只有一个元素 即为最大
     * 递归条件：让数组越来越短 -- 即数组开始下标往后一直移动
     *
     */
    public static int binarySearch2(int[] nums,int i,int low,int high){
        if(low > high){
            return -1;
        }
        int mid = (high+ low) / 2;
        if(i > mid){
            return binarySearch2(nums,i,mid + 1,high);
        }else if(i < mid){
            return binarySearch2(nums,i,low,high-1);
        }else{
            return i;
        }
    }

快速排序

/*
     * 快速排序
     */
    public static void quickSort(int[] nums,int low,int high){
        if(low > high){
            return;
        }
        //定义基准值
        int pivot = nums[low];
        int i = low;
        int j = high;
        while (i!=j){
            //从右往左 找到 比基准值小的才停
            while (nums[j] >= pivot && i<j){
                j-- ;
            }
            //从左往右找到 比基准值 大的才停
            while (nums[i] <= pivot && i<j){
                i++;
            }
            //交换两个元素位置
            int item = nums[i];
            nums[i] = nums[j];
            nums[j] = item;
        }

        nums[low] = nums[i];
        nums[i] = pivot;
        //递归排序处理 左边小于基准值得
        quickSort(nums,low,i-1);
        //递归排序处理 右边大于基准值得
        quickSort(nums,j+1,high);
    }