剑指offer题集python解法合集（持续更新）

学习目标：

1：重复数：哈希表，set

class Solution:
    def findRepeatDocument(self, documents: List[int]) -> int:
        haxi = set()
        for i in documents:
            if i in haxi:
                return i
            haxi.add(i)

2：寻找目标值 - 二维数组:有设计暴力搜索

class Solution:
    def findTargetIn2DPlants(self, plants: List[List[int]], target: int) -> bool:
        if plants == []:
            return False
        m = len(plants)
        n = len(plants[0])
        flag = 0
        for i in range(m):
            for j in range(n):
                if plants[i][j]==target:
                    flag = 1
                    i_index = i
                    j_index = j
                if flag ==1 and plants[i][j]>target and i>=i_index and j>=j_index:
                    continue
                if flag ==1 and plants[i][j]==target and i>=i_index and j>=j_index:
                    i_index = i
                    j_index = j
                if flag ==1 and plants[i][j]<target and i>=i_index and j>=j_index:
                    flag = 0
        if flag == 1:
            return True
        else:
            return False

3：替换空格

class Solution:
    def pathEncryption(self, path: str) -> str:
        return path.replace('.',' ')

4：从尾到头打印链表

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseBookList(self, head: Optional[ListNode]) -> List[int]:
        res = []
        while head:
            res.append(head.val)
            head = head.next
        n = len(res)
        r = []
        for i in range(n):
            r.append(res[n-i-1])
        return r

5： 重建二叉树[前序+中序]

# 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 deduceTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        t = TreeNode()
        if t==None or preorder==[]:
            return None
        t.val = preorder[0]
        n = len(preorder)
        for i in range(n):
            if preorder[0]==inorder[i]:
                break
        nn = i-0
        # return inorder[0:1]
        t.left = self.deduceTree(preorder[1:nn+1],inorder[0:nn])
        t.right = self.deduceTree(preorder[nn+1:n],inorder[nn+1:n])
        return t

6： 重建二叉树[后序+中序]

# 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 buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        t = TreeNode()
        if postorder ==[]:
            return None
        n = len(postorder)
        for i in range(n):
            if inorder[i]==postorder[n-1]:
                break
        t.left = self.buildTree(inorder[0:i],postorder[0:i])
        t.right = self.buildTree(inorder[i+1:n],postorder[i:n-1])
        t.val = postorder[n-1]
        return t

7： 重建二叉树[前序+后序]

# 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 constructFromPrePost(self, preorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        t = TreeNode()
        if postorder == []:
            return None
        t.val = preorder[0]
        n = len(preorder)
        if n == 1:
            return t
        for i in range(n):
            if preorder[1]==postorder[i]:
                break
        t.left = self.constructFromPrePost(preorder[1:i+2],postorder[0:i+1])
        t.right = self.constructFromPrePost(preorder[i+2:n],postorder[i+1:n-1])
        return t

8： 用两个栈实现队列【图书整理】

import queue
class CQueue:

    def __init__(self):
        q = queue.Queue()
        self.q =q


    def appendTail(self, value: int) -> None:
        self.q.put(value)


    def deleteHead(self) -> int:
        if self.q.empty():return -1
        res = self.q.get()
        return res



# Your CQueue object will be instantiated and called as such:
# obj = CQueue()
# obj.appendTail(value)
# param_2 = obj.deleteHead()

python的列表可以实现栈和队列，pop(0)是队列，pop()是栈，很方便

class CQueue:

    def __init__(self):
        # q = queue.Queue()
        self.q1 =[]
        self.q2 =[]


    def appendTail(self, value: int) -> None:
        self.q1.append(value)


    def deleteHead(self) -> int:
        if self.q1==[]:return -1
        res = self.q1.pop(0)
        return res



# Your CQueue object will be instantiated and called as such:
# obj = CQueue()
# obj.appendTail(value)
# param_2 = obj.deleteHead()

学习产出：

提示：这里统计学习计划的总量

例如：

• 技术笔记 2 遍
• CSDN 技术博客 3 篇
• 习的 vlog 视频 1 个