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

LeetCode 704 二分查找：

文章链接：二分查找
题目链接：704.二分查找

看到题目的第一想法：

所给条件为升序数组且无重复元素。

1. 逐个遍历，算法时间复杂度为O(n)
2. 二分查找。题目所给条件非常符合二分查找的特点。遍历方法有两种

1.[left, right] ：双闭区间   
	left = right时区间只有一个元素，
	因此循环判断条件为left <= right
2.[left, right)：左闭右开 
	left = right时区间为空，右端点元素取不到
	因此循环判断条件为left < right

上述的关键在于右端点是否能取到

使用左闭右开实现代码

class Solution(object):
    def search(self, nums, target):
        left, right = 0, len(nums)	# 左闭右开区间
        while left < right:
            mid = left + (right - left) // 2
            if nums[mid] > target:
                right = mid	#target在左边 [left, mid)
            elif nums[mid] < target:
                left = mid + 1	#target在右边 [mid + 1, right)
            else:	# 找到对应元素返回数组下标
                return mid
        return -1	# 没找到对应元素

实现过程中遇到的困难:

① 题目所给条件没有给数组元素个数，但是list的函数len可求长度

 right = len(nums) - 1

② if等条件判断或者while语句后需要加" : "

 if(nums[mid] < target) : 
 	left = mid + 1

③ python不能用逗号分隔的方式同时进行多个赋值。

 left = 0, right = len(nums) - 1  ×
 正确的赋值
 left, right = 0, len(nums) - 1
 or
 left = 0
 right = len(nums) - 1

④ 划分区间时对于判断条件不清晰。
先想的nums[mid] > target 再查看target归属到哪个区间，逻辑不清晰，容易出错。
比较好的思路应该是：先看target在哪个区间，再给出判断条件。

target在左区间，nums[mid] > target, right = mid - 1
target在右区间，nums[mid] < target, left = mid + 1

个人感觉比较好用的方法是画图

④ 溢出问题，计算mid不能直接写(left + right) // 2，而是left + (right - left) // 2。

---

LeetCode 27.移除元素：

文章链接：移除元素
题目链接 27.移除元素

看到题目后的想法：

原地移除元素可以理解为使用另一个元素来替换该元素

思路

1. 暴力
   通过第一层循环实现对数组元素的遍历，第二层循环实现对元素的删除操作。
   循环的i可以理解为新数组(这里实际上不是创建了一个新)要放入元素的下标，因此循环结束后，i的值为数组元素的个数
   需要注意的是
   ① 第二层循环对数组元素的删除操作是通过序号i + 1之后的元素覆盖实现的。因此删除后i指向的元素还需要进行判断，while循环更符合思考的方式，但是for循环也可以实现。
   ② 删除元素后，数组结尾的元素进行了复制，相当于要判断的数组的长度-1。

class Solution(object):
    def removeElement(self, nums, val):
        i, l = 0, len(nums)     # 暴力
        while i < l:    # 区间为左闭右开区间
            if nums[i] != val:
                i += 1
            else:
                for j in range(i + 1, l):
                    nums[j - 1] = nums[j]
                l -= 1  # 将i之后的所有元素向前移动后，相当于总数组长度-1
        return i    # 退出时i==l，新数组取不到第i个元素。因此长度为i

2. 快慢指针
   使用快指针来遍历数组，慢指针指向新数组的下一个要放入元素的下标。当快指针指向的元素值不为val时，将快指针的值赋给慢指针，同时慢指针+1。
   同时可以添加一个剪枝，当快慢指针没有指向同一个元素时，才nums[slow] = nums[fast]

class Solution(object):
    def removeElement(self, nums, val):
        slow = 0
        for fast in range(0, len(nums)):
            if nums[fast] != val:
                if fast - slow >= 1:
                    nums[slow] = nums[fast] # 当fast和slow指向不同数的时候进行赋值
                slow += 1
        return slow

3. 相向指针
   类似快排的思想，left和right分别指向数组的第一个和最后一个元素
   ① 当left指向的元素值不等于val时，left向后移动
   ② 当right指向的元素值等于val时，right向前移动
   ③ 当left和right没有指向同一个元素时，交换所指向元素的值
   ④ 整个过程直到 left > right时结束，此时left指向新数组元素的下一个元素，新数组的长度为left。
   但是相向指针和快排不同在于。
   相向指针需要判断完数组中的全部元素，因此循环条件为 left <= right；
   而快排中，目的是为了找到要放入元素的位置，因此循环结束时，判断区间应该存在一个元素/位置，也就是目标位置。循环条件为 left < right；

class Solution(object):
    def removeElement(self, nums, val):
        left, right = 0, len(nums) - 1  # 相向指针，思想类似快排，但是循环判断条件不同
        while left <= right:    # 看成是双闭区间进行判断
            while left <= right and nums[left] != val:
                left += 1
            while left <= right and nums[right] == val:
                right -= 1
            if left < right:    # left和right没有同时指向同一个元素时交换位置
                nums[left] = nums[right]
                nums[right] = val
        return left

实现过程中遇到的困难:

① 暴力解法中，删除元素后，需要对数组长度L进行修改
② 关于相向指针最后返回的新数组的长度，采用例子作为演示后可以判断出left为数组长度。或者可以这么理解，循环结束时状态为right | left，而left前的数组元素值都不等于val，right后的数组元素值都等于val。类似下面这个图，蓝色部分为新数组，所以新数组长度为left

---

LeetCode 977.有序数组的平方：

文章链接：有序数组的平方
题目链接：977.有序数组的平方

思路：

1. 暴力
   遍历对每个数组元素求平方后，再进行排序。时间复杂度为O(n + nlogn)

class Solution(object):
    def sortedSquares(self, nums):
        for i in range(len(nums)):
            nums[i] *= nums[i]
        nums.sort()	#排序的时间复杂度为nlogn
        return nums

2. 双向指针
   因为题目所给数组存在负数从而导致平方后数组不再有序。但是如果将数组划分为负数部分和正数部分，会发现两个部分都是有序的。从数组头部或尾部向中间求平方的过程中，值是递减的，不确定的是两边的值大小。
   因此采用双向指针，分别指向头部和尾部，比较其平方后的大小。
   ① 从新数组的尾部开始存放数据。

class Solution(object):
    def sortedSquares(self, nums):
        i, j = 0, len(nums) - 1
        new_list = [0] * (j + 1)		#  提前定义列表大小，以便存放结果
        k = j
        while i <= j:
            if nums[i] ** 2 > nums[j] ** 2:	# 左右边界比较，找出最大值
                new_list[k] = nums[i] ** 2
                i += 1	# i向后移动
            else:
                new_list[k] = nums[j] ** 2
                j -= 1	# j向前移动
            k -= 1
        return new_list

② 将nums的平方按从大到小的顺序添加进新列表，最后翻转list

class Solution(object):
    def sortedSquares(self, nums):
        i, j = 0, len(nums) - 1
        new_list = []
        while i <= j:
            if nums[i] ** 2 > nums[j] ** 2:
                new_list.append(nums[i] ** 2)
                i += 1
            else:
                new_list.append(nums[j] ** 2)
                j -= 1
        new_list = new_list[::-1]	# 数组元素次序翻转
        return new_list

遇到的困难：

对于list列表切片不太理解。

list[start: end] 切片时包含start位置的元素，不包含end位置的元素
list[-1] ： 返回最后一个元素
list[: 1]：start = 0, end = 1，取第一个元素
list[1:]: start = 1, end = 0, 第二个元素到最后一个元素
list[-1:]：start = -1, end = 0，返回最后一个元素
list[::1]：start = 0, end = 0，步长为1。返回原列表
list[::-1]：步长为-1，也就是从右向左按照步长为1进行切片，对原列表进行翻转
list[::2]：步长为2进行切片。如[1, 2, 3]切片后为[1, 3]

学习感悟：

首先是python的内容忘得有点多，所以学习大概是从零开始。题目本身不难，但是因为一些python语法方面的问题出错。
然后就是对于双向指针遍历后，新数组的长度为left的理解不太深入，对于这个没有一个很直观的理解从而在写代码的过程中需要借助例子来得到新数组的长度。