代码随想录算法训练营Day1

AI小手

已于 2024-05-22 12:08:01 修改

阅读量420

点赞数 15

分类专栏：代码随想录刷题文章标签： java leetcode 算法数据结构排序算法

于 2024-05-22 10:26:37 首次发布

本文链接：https://blog.csdn.net/qq_51561495/article/details/139112505

版权

代码随想录刷题专栏收录该内容

14 篇文章 0 订阅

订阅专栏

代码随想录算法训练营Day1

704.二分查找
27.移除元素

704.二分查找

704.二分查找
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

首先考虑循环结束的条件是什么，到底是 while(left < right) 还是 while(left <= right)，到底是right = middle呢，还是要right = middle - 1呢？

左闭右开

class Solution {
    public int search(int[] nums, int target) {
        // 左闭右开
        int left = 0;
        int right = nums.length;
        while (left < right) {
            int middle = left + ((right - left) >> 1);
            if (nums[middle] == target) {
                return middle;
            } else if (nums[middle] > target) {
                right = middle;
            } else {
                left = middle + 1;
            }
        }
        return -1;
    }
}

左闭右闭

class Solution {
    public int search(int[] nums, int target) {
        // 左闭右闭
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int middle = left + ((right - left) >> 1);
            if (nums[middle] == target) {
                return middle;
            } else if (nums[middle] > target) {
                right = middle - 1;
            } else {
                left = middle + 1;
            }
        }
        return -1;
    }
}

35. 插入位置搜索

35.插入位置搜索
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

输入: nums = [1,3,5,6], target = 5
输出: 2

输入: nums = [1,3,5,6], target = 2
输出: 1

输入: nums = [1,3,5,6], target = 7
输出: 4

代码和二分查找一样，主要考虑最后返回什么，画图走一遍流程即可。

左闭右开

class Solution {
    public int searchInsert(int[] nums, int target) {
        // 左闭右开
        int left = 0;
        int right = nums.length;
        while (left < right) {
            int mid = left + ((right - left) >> 1);
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] > target) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }
}

左闭右闭

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;

        while (left <= right) { 
            int mid = left + ((right - left) >> 1);
            if (nums[mid] > target) {
                right = mid - 1; 
            } else if (nums[mid] < target) {
                left = mid + 1; 
            } else {
                return mid;
            }
        }
        return left;
    }
}

69.x 的平方根

69.x 的平方根
给你一个非负整数 x ，计算并返回 x 的算术平方根。
由于返回类型是整数，结果只保留整数部分，小数部分将被舍去。

输入：x = 4
输出：2

输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842…, 由于返回类型是整数，小数部分将被舍去。

左闭右开

class Solution {
    public int mySqrt(int x) {
        if (x <= 1) {
            return x;
        }
        // 对于大于1的数x，其向下取整的算术平方根都小于等于x/2
        // 我们的搜索区间是左闭右开，因此右边界取到x/2+1
        int left = 0;
        int right = x / 2 + 1;
        while (left < right) {
            int mid = left + ((right - left) >> 1);
            if ((long)mid * mid <= x) {
                // 找到一个满足算数平方根的数，暂存ans = mid
                // 向右查找满足条件的更大，left = mid + 1。因此ans = left - 1，我们可以不用暂存ans
                left = mid + 1;
            } else {
                right = mid;    // 数值过大，不为算术平方根，向左查找
            }
        }
        return left - 1;
    }
}

左闭右闭

class Solution {
    public int mySqrt(int x) {
        if (x <= 1) {
            return x;
        }
        
        int left = 0;
        int right = x / 2;
        while (left <= right) {
            int mid = left + ((right - left) >> 1);
            if ((long)mid * mid <= x) {
                left = mid + 1;
            } else {
                right = mid - 1;   
            }
        }
        return left - 1;
    }
}

367.有效的完全平方数

367.有效的完全平方数
给你一个正整数 num。如果 num 是一个完全平方数，则返回 true ，否则返回 false 。
完全平方数是一个可以写成某个整数的平方的整数。换句话说，它可以写成某个整数和自身的乘积。

输入：num = 16
输出：true
解释：返回 true ，因为 4 * 4 = 16 且 4 是一个整数。

输入：num = 14
输出：false
解释：返回 false ，因为 3.742 * 3.742 = 14 但 3.742不是一个整数。

在这里插入代码片

左闭右开

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

左闭右闭

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

27.移除元素

27.移除元素
给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2,,]
解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3,,,_]
解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。注意这五个元素可以任意顺序返回。你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

双指针

class Solution {
    public int removeElement(int[] nums, int val) {
    
        int slow = 0;
        for (int fast = 0; fast < nums.length; fast++) {
            if (nums[fast] != val) {
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }
}

相向双指针

class Solution {
    public int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length - 1;
        while(right >= 0 && nums[right] == val) right--; //将right移到从右数第一个值不为val的位置
        while(left <= right) {
            if(nums[left] == val) { //left位置的元素需要移除
                //将right位置的元素移到left（覆盖），right位置移除
                nums[left] = nums[right];
                right--;
            }
            left++;
            while(right >= 0 && nums[right] == val) right--;
        }
        return left;
    }
}

26. 删除有序数组中的重复项

26. 删除有序数组中的重复项
给你一个非严格递增排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持一致。然后返回 nums 中唯一元素的个数。

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

输入: nums = [0]
输出: [0]

class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums.length == 0) {
            return 0;
        }
        int fast = 0, slow = 0;
        while(fast < nums.length) {
            if (nums[fast] != nums[slow]) {
            	nums[++slow] = nums[fast];
            	fast++;
            }
        }
        return slow + 1;
    }
}

283. 移动零

283. 移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

输入: nums = [0]
输出: [0]

class Solution {
    public void moveZeroes(int[] nums) {
        int slow = 0;
        for (int fast = 0; fast < nums.length; fast++) {
            if (nums[fast] != 0) {
                nums[slow] = nums[fast];
                slow++;
            }
        }
        for (int i = slow; i < nums.length; i++) {
            nums[i] = 0;
        }
    }
}

844. 比较含退格的字符串

844. 比较含退格的字符串
给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

输入：s = “ab#c”, t = “ad#c”
输出：true
解释：s 和 t 都会变成 “ac”。

输入：s = “ab##”, t = “c#d#”
输出：true
解释：s 和 t 都会变成 “”。

输入：s = “a#c”, t = “b”
输出：false
解释：s 会变成 “c”，但 t 仍然是 “b”。

class Solution {
    public boolean backspaceCompare(String s, String t) {
        char[] ss = s.toCharArray();
        char[] tt = t.toCharArray();

        return helper(ss).equals(helper(tt));
    }

    String helper(char[] c){
        int i = 0,j = 0;
        while(j < c.length){
            if(c[j] != '#'){ //遇到字母 两个指针都往前走
                c[i++] = c[j++];
            }else {
                j++;
                if(i > 0) i--;  // 遇到 #, i 指针向后退
            }
        }
        return new String(c).substring(0,i);
    }
}

977. 有序数组的平方

977. 有序数组的平方
给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100] 排序后，数组变为 [0,1,9,16,100]

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

class Solution {
    public int[] sortedSquares(int[] nums) {
        int right = nums.length - 1;
        int left = 0;
        int[] result = new int[nums.length];
        int index = result.length - 1;
        while (left <= right) {
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
                // 正数的相对位置是不变的， 需要调整的是负数平方后的相对位置
                result[index--] = nums[left] * nums[left];
                ++left;
            } else {
                result[index--] = nums[right] * nums[right];
                --right;
            }
        }
        return result;
    }
}

AI小手

关注

15
点赞
踩
4

收藏

觉得还不错? 一键收藏
1
评论
代码随想录算法训练营Day1

704.二分查找给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。主要考虑边界情况
复制链接

扫一扫