代码随想录算法训练营第一天| 704. 二分查找，27. 移除元素，977.有序数组的平方

---

🔗 题目链接

LeetCode 704. 二分查找

📖 考察点

📖 题意理解

1.数组升序 2.存在返回 返回数组下标 不存在返回-1

💡 解题思路

思路一：暴力枚举

直接便历

思路二：

二分查找

🔑 关键点总结

区间和条件的关系

💻 代码实现

JavaScript

var search = function (nums, target) {
	let start = 0;
	let end = nums.length;
	while (start < end) {
		let mid = ~~((start + end)/ 2);
		if (target > nums[mid]) {
			start = mid + 1;
		} else if (target < nums[mid]) {
			end = mid;
		} else {
			return mid;
		}
	}
	return -1;
};

Rust

 pub fn search(nums: Vec<i32>, target: i32) -> i32 {
        let mut left = 0;
        let mut right: i32 = nums.len() as i32;
        while left < right {
            let middle = (left + right) / 2;
            match target.cmp(&nums[middle as usize]) {
                Ordering::Greater => left = middle + 1,
                Ordering::Less => right = middle,
                Ordering::Equal => return middle,
            }
        }
        -1
    }

---

⏱️ 复杂度分析

📚 总结与反思

1.js 中 直接除得到的类型是小数，需要转化

---

🔗 题目链接

LeetCode 27. 移除元素

📖 考察点

双指针

📖 题意理解

1.原地移出，不使用新的内存

💡 解题思路

思路一：暴力枚举

便历nums，找到val，把后面所有元素前移

思路二：

设置指针，把非val填入其中

🔑 关键点总结

区间和条件的关系

💻 代码实现

JavaScript

var removeElement = function(nums, val) {
    let ptr = 0;
    for(let i = 0;i<nums.length;i++){
        if(nums[i]!==val){
            nums[ptr] = nums[i]
            ptr++;
        }
    }
    return ptr;
};

Rust

 pub fn remove_element(nums: &mut Vec<i32>, val: i32) -> i32 {
        let mut stack_size = 0;
        for i in 0..nums.len() {
            if nums[i] != val {
                nums[stack_size] = nums[i]; // 把 nums[i] 入栈
                stack_size += 1;
            }
        }
        stack_size as _
    }

---

⏱️ 复杂度分析

📚 总结与反思

1.关注题目的出参入参

---

🔗 题目链接

LeetCode 977. 有序数组的平方

📖 考察点

双指针

📖 题意理解

1.输入：非递减顺序数组， 2.输出：数组的平方组成的新数组，同样按非递减顺序排序

💡 解题思路

思路一：先平方后排序

先为数组求平方，然后排序

思路二：

双指针，记录头和尾，比较平方的大小，大的放入数组末尾

🔑 关键点总结

💻 代码实现

JavaScript

var sortedSquares = function(nums) {
    let start = 0;
    let end = nums.length-1;
    const res = [];
    while (start<=end){
        const start_sq = nums[start] * nums[start];
        const end_sq = nums[end] * nums[end];
        if(start_sq < end_sq){
            res.unshift(end_sq);
            end--;
        }else{
            res.unshift(start_sq);
            start++;
        }
    }
    return res;
};

Rust

pub fn sorted_squares(nums: Vec<i32>) -> Vec<i32> {
    let n = nums.len();
    let mut start = 0;
    let mut end = n - 1;
    let mut res: Vec<i32> = vec![0; n];
    let mut ptr = end;
    while start <= end {
        let start_sq = nums[start] * nums[start];
        let end_sq = nums[end] * nums[end];
        match start_sq.cmp(&end_sq) {
            Ordering::Greater => {
                res[ptr] = start_sq as i32;
                start += 1;
                ptr -= 1;
            }
            _ => {
                res[ptr] = end_sq as i32;
                if end == 0 {
                    break;
                }
                end -= 1;
                ptr -= 1;
            }
        }
    }
    res
}

⏱️ 复杂度分析

📚 总结与反思

1.rust的无符号整数类型会越界，0-1会从0变成极大值，导致代码不按照预期执行