常见算法的进阶打怪路程|数组

数组理论基础

数组是存放在连续内存空间上的相同类型数据的集合

数组可以方便的通过下标索引的方式获取到下标下对应的数据。

需要两点注意的是

• 数组下标都是从0开始的。
• 数组内存空间的地址是连续的

正是因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。

数组的元素是不能删的，只能覆盖。

二维数组

在C++中二维数组在地址空间上是连续的。

java中二维数组的每一行头结点的地址是没有规则的，更谈不上连续。

滑动窗口最主要的思路就是如何移动起始位置

例题

704. 二分查找 - 力扣（LeetCode）

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        lf,rg=0,len(nums)-1
        while lf<=rg:
            mid=(lf+rg)//2
            if nums[mid]>target:
                rg=mid-1
            elif nums[mid]<target:
                lf=mid+1
            else:
                return mid
        return -1

35. 搜索插入位置 - 力扣（LeetCode）

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        lf,rg=0,len(nums)-1
        while lf<=rg:
            mid=(lf+rg)//2
            if nums[mid]>target:
                rg=mid-1
            elif nums[mid]<target:
                lf=mid+1
            else:
                return mid
        return lf

34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）

class Solution:
    def search(self, nums, target):
        lf, rg = 0, len(nums) - 1
        while lf <= rg:
            mid = (lf + rg) // 2
            if nums[mid] < target:
                lf = mid + 1
            elif nums[mid] > target:
                rg = mid - 1
            else:

                return mid
        return -1

    def searchRange(self, nums: List[int], target: int) -> List[int]:
        re = self.search(nums, target)
        if re == -1:
            return [-1, -1]
        lf, rg = re, re
        while lf - 1 >= 0 and nums[lf - 1] == target:
            lf -= 1
        while rg + 1 <= len(nums) - 1 and nums[rg + 1] == target:
            rg += 1
        return [lf, rg]

69. x 的平方根 - 力扣（LeetCode）

class Solution:
    def mySqrt(self, x: int) -> int:
        lf,rg=0,x
        while lf<=rg:
            mid=(lf+rg)//2
            if mid*mid>x:
                rg=mid-1
            elif mid*mid<x:
                lf=mid+1
            else:
                return mid
        return rg

367. 有效的完全平方数 - 力扣（LeetCode）

class Solution:
    def isPerfectSquare(self, num: int) -> bool:
        lf,rg=0,num
        while lf<=rg:
            mid=(lf+rg)//2
            if mid*mid>num:
                rg=mid-1
            elif mid*mid<num:
                lf=mid+1
            else:
                return True
        return False
            

27. 移除元素 - 力扣（LeetCode）

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        lf=0
        for rg in range(len(nums)):
            if nums[rg]!=val:
                nums[lf]=nums[rg]
                lf+=1
        print(nums,lf)
        return lf

26. 删除有序数组中的重复项 - 力扣（LeetCode）

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        lf=1
        for rg in range(1,len(nums)):
            if nums[rg]!=nums[rg-1]:
                nums[lf]=nums[rg]
                lf+=1
        return lf

283. 移动零 - 力扣（LeetCode）

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        lf=0
        for rg in range(len(nums)):
            if nums[rg]!=0:
                nums[lf]=nums[rg]
                lf+=1
        for rg in range(lf,len(nums)):
            nums[rg]=0

844. 比较含退格的字符串 - 力扣（LeetCode）

class Solution:
    def backspacestr(self,s):
        lf=0
        s=list(s)
        for rg in range(len(s)):
            if s[rg]=='#':
                if lf>=1:
                    lf-=1
            else:
                s[lf]=s[rg]
                lf+=1
        return "".join(s[:lf])
    def backspaceCompare(self, s: str, t: str) -> bool:
        s=self.backspacestr(s)
        t=self.backspacestr(t)
        return s==t

977. 有序数组的平方 - 力扣（LeetCode）

##暴力排序
class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        nums.sort(key=lambda x:abs(x),reverse=False)
        print(nums)
        for i in range(len(nums)):
            nums[i]=nums[i]*nums[i]
        return nums
##双指针
class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        lf,rg,re=0,len(nums)-1,len(nums)-1
        lst=[0]*len(nums)
        while lf<=rg:
            if nums[lf]*nums[lf]>nums[rg]*nums[rg]:
                lst[re]=nums[lf]*nums[lf]
                lf+=1
            else:
                lst[re]=nums[rg]*nums[rg]
                rg-=1
            re-=1
        return lst