算法学习day05数组part扩展-69、35、34、367、26

package LeetCode.arraypart01;
/**
 * 69. x 的平方根
 * 给你一个非负整数 x ，计算并返回 x 的 算术平方根 。
 * 由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。
 * 注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。
 * 示例：
 * 输入：x = 4
 * 输出：2
 * */
/**
 * 思路：
 * 这道题目怎么想到用二分呢？
 * 首先是找x的平方根，平方根是在0到x之间查找，这个时候就可以利用二分来缩小查找范围
 * 因为本身是一个递增是数组
 * 所以：
 * 左边界是0，右边界是x，
 * 查找中间元素 mid * mid 和x的比较，
 * 1.如果小于等于x，说明mid可能是平方根，这个时候接着向右寻找，所以直接left = mid +1
 * 2.如果 mid * mid > x,那就直接right = mid — 1 ，直接查找另一半，返回ans
 *
 * */
public class MySqrtX_69 {
    public static void main(String[] args) {
        int x = 9;
        int result = mySqrt(x);
        System.out.println(result);
    }
    public static int mySqrt(int x) {
        int left = 0, right = x, ans = -1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if ((long) mid * mid <= x) {
                ans = mid;
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return ans;
    }

}

 

package LeetCode.arraypart01;
/**
 * 35. 搜索插入位置
 * 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
 * 请必须使用时间复杂度为 O(log n) 的算法。
 */
public class SearchInsert_35 {
    public static void main(String[] args) {
        int [] arr = {1,3,5,7,9,11};
        int target = 12;
        int result = search_insert(arr,target);
        System.out.println(result);
    }
    /**
     * 暴力方法：
     * 时间复杂度：O(n)
     * 空间复杂度：O(1)
     */
    public static int search_insert_violence(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] >= target) { // 一旦发现大于或者等于target的num[i]，那么i就是我们要的结果
                return i;
            }
        }
        // 目标值在数组所有元素之后的情况，// 如果target是最大的，或者 nums为空，则返回nums的长度
        return nums.length;
    }

    /**
     * 二分法：
     * 时间复杂度：O(log n)
     * 空间复杂度：O(1)
     * */
    public static int search_insert(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] > target){
                right = mid - 1;
            }else {
                left = mid + 1;
            }
        }
        return right+1;
    }
}

package LeetCode.arraypart01;
/**
 * 34. 在排序数组中查找元素的第一个和最后一个位置
 * 给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。
 * 如果数组中不存在目标值 target，返回[-1, -1]。
 * 你必须设计并实现时间复杂度为 O(log n)的算法解决此问题。
 * 示例：
 * 输入：nums = [5,7,7,8,8,10], target = 8
 * 输出：[3,4]
 */

/**
 * 1.直观的思路肯定是从前往后遍历一遍。用两个变量记录第一次和最后一次遇见target 的下标，但这个方法的时间复杂度为
 *      O(n)，没有利用到数组升序排列的条件。
 * 2.由于数组已经排序，因此整个数组是单调递增的，我们可以利用二分法来加速查找的过程
 * 考虑 target 开始和结束位置，其实我们要找的就是数组中「第一个等于 target 的位置」（记为leftIdx）
 *      和「第一个大于target 的位置减一」（记为rightIdx）。
 *
 * 二分查找中，寻找leftIdx 即为在数组中寻找第一个大于等于target 的下标，
 * 寻找rightIdx 即为在数组中寻找第一个大于target 的下标，然后将下标减一。
 * 两者的判断条件不同，为了代码的复用，
 *      我们定义 binarySearch(nums, target, lower) 表示在nums 数组中二分查找target 的位置，如果lower 为true，
 *      则查找第一个大于等于target 的下标，否则查找第一个大于target 的下标。
 * 最后，因为
 * target 可能不存在数组中，因此我们需要重新校验我们得到的两个下标
 * leftIdx 和 rightIdx，看是否符合条件，如果符合条件就返回[leftIdx,rightIdx]，
 * 不符合就返回[−1,−1]。
 *
 * */

public class SearchRange_34 {
    public static void main(String[] args) {
        int[] arr = {5, 7, 7, 8, 8, 10};
        int target = 8;
        int[] result = search_range(arr, target);
        for (int i = 0; i < result.length; i++) {
            System.out.print(result[i] + " ");
        }
    }
    public static int[] search_range(int[] nums, int target) {
        int leftBorder = searchBorder(nums, target, true);
        int rightBorder = searchBorder(nums, target, false);
        return new int[]{leftBorder, rightBorder};
    }
    //传入true表示寻找左边界，传入false表示寻找右边界
    public static int searchBorder(int[] nums, int target, boolean flag){
        int left = 0;
        int right = nums.length - 1;
        int border = -1;
        while(left <= right){
            int mid = (right + left) / 2;
            if(nums[mid] > target){
                right = mid - 1;
            }else if(nums[mid] < target){
                left = mid + 1;
            }else{
                //true 寻找左边界
                if(flag){
                    right = mid - 1;
                }else{
                    left = mid + 1;
                }
                border = mid;
            }
        }
        return border;
    }
}

 

package LeetCode.arraypart01;
/**
 * 367. 有效的完全平方数
 * 给你一个正整数 num 。如果 num 是一个完全平方数，则返回 true ，否则返回 false 。
 * 完全平方数 是一个可以写成某个整数的平方的整数。换句话说，它可以写成某个整数和自身的乘积。
 * 不能使用任何内置的库函数，如 sqrt 。
 * 示例：
 * 输入：num = 16
 * 输出：true
 * 解释：返回 true ，因为 4 * 4 = 16 且 4 是一个整数。
 * */
/**
 * 思路：
 * 其实这个问题很简单
 * 和之前的平方根很像，只不过有几点需要注意一下
 * 判断平方的时候，需要加上 long类型
 * 然后将平方结果和num相比
 * */
public class ValidPerfectSquare_367 {
    public static void main(String[] args) {
        int num = 4;
        boolean result = isPerfectSquare(num);
        System.out.println(result);
    }

    public static boolean isPerfectSquare(int num) {
        int left = 0, right = num;
        while (left <= right) {
            int mid = (right + left) / 2 ;
            long square = (long) mid * mid;
            if (square < num) {
                left = mid + 1;
            } else if (square > num) {
                right = mid - 1;
            } else {
                return true;
            }
        }
        return false;
    }
}

 

package LeetCode.arraypart01;
/**
 * 26.删除有序数组中的重复项
 * 给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。
 * 由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么nums的前 k 个元素应该保存最终结果。
 * 将最终结果插入nums 的前 k 个位置后返回 k 。 // 看到这我想到的是插入排序，
 * 不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
 * */
/**
 * 双指针
 * 思路：快慢指针，
 * 设置两个指针，一个在前，一个在后
 * 比较 p 和 q 位置的两个数，如果相等，q后移，不相等，则将后面的数插入p+1索引位置，然后p后移
 * */

public class RemoveDuplicatesfromSortedArray_26 {
    public static void main(String[] args) {
        int [] arr = {1,3,3,5,5,6,7,7,7,8};
        int result = removeDuplicates(arr);
        System.out.println(result);

    }

    public static int removeDuplicates(int[] nums) {
        if(nums == null || nums.length == 0) return 0;
        int p = 0;
        int q = 1;
        while(q < nums.length){
            if(nums[p] != nums[q]){
                nums[p + 1] = nums[q];
                p++;
            }
            q++;
        }
        return p + 1;
    }

}