更新中。。。有错误请指正

数组

二分查找704

class Solution:
    def search(self,nums:list,target:int)->int:
        left = 0
        right = len(nums)-1
        while left<=right:
            mid = (left+right)//2
            guess = nums[mid]
            if guess == target:
                return mid
                break
            elif guess > target:
                right = mid -1
            else:
                left = mid + 1
        return -1


nums = [int(c) for c in input().split(" ")]#⭐
target = int(input())
solu = Solution()
out = solu.search(nums,target)
print(out)

相关题目推荐
35.搜索插入位置
和二分法的区别就是一个返回-1，一个返回left。

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

34.在排序数组中查找元素的第一个和最后一个位置

69.x 的平方根
367.有效的完全平方数

移除元素27

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        length = len(nums)
        new_len = length

        for i in range(new_len):
            if nums[i] == val:
                new_len = new_len -1
                for j in range(i, new_len):
                    nums[j]= nums[j+1]
                nums[-1] = 101
                print(nums)##
        return new_len,nums[:new_len]
nums = [int(c) for c in input().split(" ")]
val = int(input())
solu = Solution()
out = solu.removeElement(nums,val)
print(out)

输入为：

[0,1,2,2,3,0,4,2]
2

时，会出现错误

双指针法

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

相关题目推荐

• 26.删除排序数组中的重复项
• 283.移动零
• 844.比较含退格的字符串
• 977.有序数组的平方

有序数组的平方

长度最小的子数组

链表

链表相交

160.链表相交

class ListNode:
    def __init__(self,x):
         self.val = x
         self.next = None
class Solution:
    def getIntersectionNode(self,headA: ListNode, headB:ListNode) ->ListNode:
         A = headA
         B = headB
         while A != B:
              A = A.next if A else headB
              B = B.next if B else headA
          return A

A = A.next if A else headB
等价于
if A：
   A = A.next
else:
   A = headB

哈希表

有效的字母异位词

242.有效的字母异位词

class Solution:
    def isAnagram(self,s:str,t:str) ->bool:
        n = 26
        s_count = [0]*n
        t_count = [0]*n
        for i in s:
            s_count[ord(i) - ord("a")] += 1
        for i in t:
            t_count[ord(i) - ord("a")] += 1
        if s_count == t_count:
            return True
        else:
            return False

注意：

ord(i) - ord("a")

两个数组的交集

349.两个数组的交集

class Solution:
    def intersection(self,nums1:List[int],nums2:List[int])->List[int]:
        nums1 = set(nums1)
        length2 = len(nums2)
        count = []
        for i in range(length2):
            if nums2[i] in nums1:
                count.append(nums2[i])
        count = set(count)
        count = list(count)
        return count   

快乐数

202.快乐数

class Solution:
    def isHappy(self, n: int) ->bool:
        while n != 1:
            s = str(n)
            sum = 0
            sum_count = []
            for s_element in s:
                sum += int(s_element)**2
            if sum in sum_count:
                return False
            else:
                sum_count.append(sum)
            n = sum
        return True

超时了。。。

1.两数之和

什么时候使用哈希法，当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

class Solution:
    def twoSum (self,nums: List[int],target:int)->List[int]:
        hashtable = dict()
        length = len(nums)
        for i,num in enumerate(nums):
            if target - num in hashtable:
            # if target - num in set(nums[i+1:]):
                return [i, hashtable[target-num]]
            hashtable[nums[i]] = i  #在哈希表中以元素值为键，以对应下标为值进行存储。
        return []

赎金信

383

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        ransom_count = [0] * 26
        magazine_count = [0] * 26
        for c in ransomNote:
            ransom_count[ord(c) - ord('a')] += 1
        for c in magazine:
            magazine_count[ord(c) - ord('a')] += 1
        return all(ransom_count[i] <= magazine_count[i] for i in range(26))
        #这是一个Python代码行，用于检查一个名为ransom_count的列表中的每个字母在另一个名为magazine_count的列表中是否都有足够的数量。这两个列表都包含26个元素，分别代表26个字母。如果有任何一个字母的数量在ransom_count中大于在magazine_count中的数量，那么这个条件将返回False，否则返回True。换句话说，这个代码行的作用是确保magazine_count中的每个字母都至少有ransom_count中相应字母的数量那么多。

字符串

反转字符串II

class Solution:
    def reverStr(self,s:str,k:int)->str:
        s = list(s)  # @1
        L = len(s)//(2*k)
        for loop in range(L):
            for i in range(k//2):
                temp = s[loop*2*k+i]
                s[loop*2*k+i] = s[loop*2*k+k-i-1]
                s[loop*2*k+k-i-1] = temp
        left = len(s)-L*2*k
        if 0<left < k:
            for i in range(left):
                temp = s[left+i-1]
                s[left+i-1] = s[len(s)-1-i]
                s[len(s)-1-i] = temp
        if k<=left<2*k:
            for i in range(k//2):
                temp = s[L*2*k+i]
                s[L*2*k+i] = s[L*2*k+k-i-1]
                s[L*2*k+k-i-1] = temp
        result = ''.join(s)
        return result

1、一开始@1行没有加，报错：

TypeError: 'str' object does not support item assignment

原因：这个错误是因为正在尝试更改一个字符串对象的某个字符，但是字符串是不可变的，也就是说，它们的值一旦被赋予就不能被修改。因此，如果尝试对字符串进行item assignment，Python会引发TypeError。

例如，以下代码将导致TypeError: ‘str’ object does not support item assignment：

Copy Codemy_string = "Hello"
my_string[0] = "J"  # trying to change the first character from "H" to "J"

为了避免这个错误，可以使用其他数据类型来存储和操作可变的数据，例如列表或字典。如果需要在字符串中进行修改，则可以创建一个新的字符串并使用字符串切片来复制原始字符串的内容，并使用新值替换需要更改的部分。

注意：在 Python 和 Java 等语言中，字符串都被设计成「不可变」的类型，即无法直接修改字符串的某一位字符，需要新建一个字符串实现。在 C++ 语言中， string 被设计成「可变」的类型，因此可以在不新建字符串的情况下实现原地修改。

2、str转list：

s = list(s)

list转str：

result = ''.join(s)

替换空格

class Solution:
    def replaceSpace(self,s:str) -> str:
        res = []
        for i in s:
            if i == ' ':
                res.append("%20")
            else:
                res.append(i)
        return "".join(res)

左旋转字符串

class Solution:
    def reverseLeftWords(self,s:str,n:int)->str:
        s = list(s)

        for i in range(n):
            temp = s[0]
            for j in range(len(s)-1):
                s[j] = s[j+1]
            s[len(s)-1] = temp
        return "".join(s)

超时了。。。

#法二：切片
class Solution:
     def reverseLeftWords(self,s:str,n:int)->str:
         return s[n:]+s[:n]

# 法三：列表遍历拼接
class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        res = []
        for i in range(n, len(s)):
            res.append(s[i])
        for i in range(n):
            res.append(s[i])
        return ''.join(res)

重复的字符串（不会）

栈与队列

用栈实现队列232

class MyQueue:

    def __init__(self):
        """
        in主要负责push，out主要负责pop
        """
        self.stack_in = []
        self.stack_out = []

    def push(self, x: int) -> None:
        """
        有新元素进来，就往in里面push
        """
        self.stack_in.append(x)
#pop 方法从队列头部删除元素并返回该元素。如果 stack_out 不为空，则将其栈顶元素#弹出；否则，将所有 stack_in 中的元素从后往前取出，添加到 stack_out 中，并弹出 stack_out 栈顶元素。
    def pop(self) -> int:
        """
        Removes the element from in front of queue and returns that element.
        """
        if self.empty():
            return None
        
        if self.stack_out:
            return self.stack_out.pop()
        else:
            for i in range(len(self.stack_in)):
                self.stack_out.append(self.stack_in.pop())
            return self.stack_out.pop()    
#peek 方法返回队列头部元素，但不删除该元素。该方法可以调用 pop 方法，将结果存储在 ans 变量中，然后将 ans 添加回 stack_out 并返回它。
    def peek(self) -> int:
        ans = self.pop()
        self.stack_out.append(ans)
        return ans
        #首先调用队列的 pop 方法弹出队列头部的元素，并将其存储在变量 ans 中。
        # 然后将该元素添加到队列的 stack_out 栈中。
        # 最后返回变量 ans，即为队列的头部元素。

    def empty(self) -> bool:
        return not (self.stack_in or self.stack_out)

用队列实现栈225

from collections import deque
class MyStack:
    def __init__(self):
        self.que = deque()

    def push(self,x:int)->None:
        """
        将x压入栈顶
        """
        self.que.append(x)

    def pop(self)->int:
        """
        移除并返回栈顶元素
        """
        if self.empty():
            return None

        for i in range(len(self.que)-1):
            self.que.append(self.que.popleft())
        return self.que.popleft()


    def top(self)->int:
        """
        返回栈顶元素
        """
        ans = self.pop()
        self.que.append(ans)
        return ans
    
    def empty(self)->bool:
        return not self.que

有效的括号20

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        mapping = {
            "(":")",
            "[":"]",
            "{":"}"
        }
        # 第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号return false
        # 第二种情况：遍历字符串匹配的过程中，发现栈里没有我们要匹配的字符。所以return false
        # 第一种情况：此时我们已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false，否则就return true
        for item in s:
            if item in mapping.keys():
                stack.append(mapping[item])
            elif not stack or stack[-1] != item:
                return False
            else:
                stack.pop()
        return True if not stack else False

删除字符串中的所有相邻重复项1047

class Solution:
    def removeDuplicates(self,s: str)->str:
        stack = []
        for item in s:
            if stack and stack[-1] == item:
                stack.pop()
            else:
                stack.append(item)
        return "".join(stack)

二叉树

二叉树的递归遍历

# 前序遍历-递归-LC144_二叉树的前序遍历
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []

        left = self.preorderTraversal(root.left)
        right = self.preorderTraversal(root.right)

        return  [root.val] + left +  right
        
        
        
# 中序遍历-递归-LC94_二叉树的中序遍历
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if root is None:
            return []

        left = self.inorderTraversal(root.left)
        right = self.inorderTraversal(root.right)

        return left + [root.val] + right
        
 
 
# 后序遍历-递归-LC145_二叉树的后序遍历
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []

        left = self.postorderTraversal(root.left)
        right = self.postorderTraversal(root.right)

        return left + right + [root.val]

二叉树的迭代遍历

# 前序遍历-迭代-LC144_二叉树的前序遍历
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        # 根结点为空则返回空列表
        if not root:
            return []
        stack = [root]
        result = []
        while stack:
            node = stack.pop()
            # 中结点先处理
            result.append(node.val)
            # 右孩子先入栈
            if node.right:
                stack.append(node.right)
            # 左孩子后入栈
            if node.left:
                stack.append(node.left)
        return result


# 中序遍历-迭代-LC94_二叉树的中序遍历
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        stack = []  # 不能提前将root结点加入stack中
        result = []
        cur = root
        while cur or stack:
            # 先迭代访问最底层的左子树结点
            if cur:     
                stack.append(cur)
                cur = cur.left		
            # 到达最左结点后处理栈顶结点    
            else:		
                cur = stack.pop()
                result.append(cur.val)
                # 取栈顶元素右结点
                cur = cur.right	
        return result
        
        
        
# 后序遍历-迭代-LC145_二叉树的后序遍历
class Solution:
   def postorderTraversal(self, root: TreeNode) -> List[int]:
       if not root:
           return []
       stack = [root]
       result = []
       while stack:
           node = stack.pop()
           # 中结点先处理
           result.append(node.val)
           # 左孩子先入栈
           if node.left:
               stack.append(node.left)
           # 右孩子后入栈
           if node.right:
               stack.append(node.right)
       # 将最终的数组翻转
       return result[::-1]

二叉树的统一迭代法

翻转二叉树226

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return root

        left = self.invertTree(root.left)
        right = self.invertTree(root.right)
        root.left, root.right = right, left
        return root

中结点先处理

       result.append(node.val)
       # 左孩子先入栈
       if node.left:
           stack.append(node.left)
       # 右孩子后入栈
       if node.right:
           stack.append(node.right)
   # 将最终的数组翻转
   return result[::-1]

### 二叉树的统一迭代法

### 翻转二叉树226

class Solution:
def invertTree(self, root: TreeNode) -> TreeNode:
if not root:
return root

    left = self.invertTree(root.left)
    right = self.invertTree(root.right)
    root.left, root.right = right, left
    return root