剑指offer思路整理（个人向）31-37

最新推荐文章于 2022-01-08 00:17:12 发布

fantastic_bobo

最新推荐文章于 2022-01-08 00:17:12 发布

阅读量136

点赞数

文章标签：数据结构算法

本文链接：https://blog.csdn.net/qq_37876289/article/details/115249758

版权

剑指31.栈的压入、弹出序列

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

示例 1：

输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
输出：true
解释：我们可以按以下顺序执行：
push(1), push(2), push(3), push(4), pop() -> 4,
push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1

1.指针i遍历pushed数组，当遇到第一个出栈的数字（pushed[i] == popped[0]）的时候，i回退，然后pushed数组和popped数组里的数字pop掉。

class Solution:
    def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:
        i = 0
        while popped!=[]:
            if i >= len(pushed):
                return False
            if pushed[i] == popped[0]:
                pushed.pop(i)
                popped = popped[1:]
                if i == 0:
                    i = i - 1
                else:
                    i = i - 2
            i = i+1
        return True

2.新建一个堆栈，然后模拟入栈出栈操作，看能不能获得popped

class Solution:
    def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:
        stack, i = [], 0
        for num in pushed:
            stack.append(num)
            while stack and stack[-1] == popped[i]:
                stack.pop()
                i += 1
        return not stack

**自我反思：**这个方法比我的方法好的地方在于，引入了一个指针i，这样只需要stackpop就可以了。

剑指32-1.从上到下打印二叉树

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

例如:
给定二叉树: [3,9,20,null,null,15,7],

[3,9,20,15,7]

1.其实就是bfs，利用栈实现。

class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        stack = []
        if root == None:
            return []
        result = []
        stack.append(root)
        while stack:
            node = stack.pop()
            if node != None:
                result.append(node.val)
            if node.left:
                stack.insert(0,node.left)
            if node.right:
                stack.insert(0,node.right)
        return result

2.但上面这个做法的问题就在于，每次都得在最前面插入，才能保证pop出来的时候是从左到右的，所以可以使用collections.deque()可以使用popleft()

class Solution:
def levelOrder(self, root: TreeNode) -> List[int]:
    if not root: return []
    result = []
    que = collections.deque()
    que.append(root)
    while que:
        temp = que.popleft()
        result.append(temp.val)
        if temp.left: que.append(temp.left)
        if temp.right: que.append(temp.right)
    return result

自我反思： 感觉还是有些库函数不够熟练，还得加强。

剑指32-2.从上到下打印二叉树2

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

例如:

给定二叉树: [3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：
[
  [3],
  [9,20],
  [15,7]
]

1.和上一道题的区别不是很大，只是返回结果有了不同，我多定义了一个临时栈。之前直接放进stack的node，现在先放进temp临时栈里，当stack为空了，就把 [这一行] append到结果里，然后再把temp给stack。

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if root == None:
            return []
        row = []
        result = []
        stack = []
        temp = []
        stack.append(root)
        while stack!=[]:
            node = stack.pop()
            if node!=None:
                row.append(node.val)
            if node.left!=None:
                temp.insert(0,node.left)
            if node.right!=None:
                temp.insert(0,node.right)
            if stack == []:
                stack = temp
                temp = []
                result.append(row)
                row = []
        
        return result

2.K神巧妙的利用for循环，解决了我的临时堆栈问题

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        result = []
        stack = collections.deque()
        stack.append(root)
        while stack:
            temp = []
            for _ in range(len(stack)):
                node = stack.popleft()
                temp.append(node.val)
                if node.left: stack.append(node.left)
                if node.right: stack.append(node.right)
            result.append(temp)
        return result

**自我反思：**说实话，无论多简单的题，总能从K神那里找到更清晰更简单的思路，真的学到了。

剑指32-3.从上到下打印二叉树3

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

例如:

给定二叉树: [3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7
返回其层次遍历结果：
[
  [3],
  [20,9],
  [15,7]
]

1.相对于上一题，又加了一个参数r，来判断这是单数层还是双数层，然后决定放入堆栈的顺序。

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if root == None:
            return []
        result = []
        stack = []
        temp = []
        row = []
        stack.append(root)
        r = 0
        while stack:
            node = stack.pop()
            if node:
                row.append(node.val)
            if r%2==0:
                if node.left:
                    temp.append(node.left)
                if node.right:
                    temp.append(node.right)
            else:
                if node.right:
                    temp.append(node.right)
                if node.left:
                    temp.append(node.left)
            if stack == []:
                stack = temp
                temp = []
                result.append(row)
                row = []
                r += 1
        return result

2.依然按上一节K神的方法做，只需要在最后result.append的时候，分奇偶来选择正序或者倒叙。

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        result = []
        stack = collections.deque()
        stack.append(root)
        while stack:
            temp = []
            for _ in range(len(stack)):
                node = stack.popleft()
                temp.append(node.val)
                if node.left: stack.append(node.left)
                if node.right: stack.append(node.right)
            result.append(temp[::-1] if len(result)%2 else temp)
        return result

**自我反思：**这里判断单双层的方法非常巧妙，没有像我一样单独设一个数，每次+1，而是直接判断result里元素的个数。学到了学到了。

剑指33.二叉搜索树的后续遍历序列

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。

参考以下这颗二叉搜索树：

示例 1：

输入: [1,6,3,2,5]
输出: false

1.序列的最后一位为当前树的根节点，进行递归，每次根据列表的最后一位将前面的序列分成左右子树，直到左右都为[]，则return True，如果分割子树的过程中，发现违背了二叉搜索树的规律，则return False

class Solution:
    def verifyPostorder(self, postorder: List[int]) -> bool:     
        return self.recursion(postorder) 
    def recursion(self,treelist):
        if treelist == []:
            return True
        head = treelist[-1]
        left = len(treelist)-1
        for i in range(len(treelist) - 1):
            if treelist[i] > head:
                left = min(i,left)
            if treelist[i] < head and i > left:
                return False
        return self.recursion(treelist[:left]) and self.recursion(treelist[left:-1])

2.大佬解法，使用辅助单调栈，讲道理有一点点难懂，不如递归直白。但是时间复杂度比递归要低。大致意思就是，逆序原序列 [root right left]，对于每一个节点，找他作为左子树的最近根节点，如果它后面的值大于根节点，则不是后续遍历的结果。如果遇到递减节点，说明后面的节点在一棵新的小左子树上，这时候更新root。

class Solution:
    def verifyPostorder(self, postorder: List[int]) -> bool:
        stack = []
        root = float('+inf')
        for i in range(len(postorder)-1,-1,-1):
            if postorder[i] > root: return False
            while stack and postorder[i] < stack[-1]:
                root = stack.pop()
            stack.append(postorder[i])
        return True

**自我反思：**说实话，逆序然后单调辅助栈不太好想，做题的时候优先考虑二分递归吧。

剑指35.复杂链表的复制

请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。
示例 1：
在这里插入图片描述

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

1.这道题的难点就在于多了一个random，我的方法巨tm长，也懒得优化了。一共有三次遍历，第一次遍历把原链表按照next的顺序依次放入List里，这样每个node就有了一个index。第二次遍历，一边按照next的顺序复制链表，一边把每个node的random的index放进List里。最后一次遍历，如果node有random，就把它从List里取出来，接到random指针上。（总觉得哪里怪怪的，好像多写了一些没必要的步骤。）总体来讲，必须先按next顺序复制完整个链表，才能去连接random。

class Solution:
    def copyRandomList(self, head: 'Node') -> 'Node':
        if not head:
            return
        result = Node(head.val)
        temp = result
        List = []
        List_h = []
        random = []
        temp_head = head
        temp_head2 = head
        index = []
        while temp_head2:
            List_h.append(temp_head2)
            temp_head2 = temp_head2.next

        while temp_head.next:
            temp.next = Node(temp_head.next.val)
            List.append(temp)
            if temp_head.random:
                index.append(List_h.index(temp_head.random))
            else:
                index.append(-1)
            temp = temp.next
            temp_head = temp_head.next 
            
        List.append(temp)
        if temp_head.random:
            index.append(List_h.index(temp_head.random))
        else:
            index.append(-1)
        
        temp = result
        n = 0
        while temp:
            if not temp.next:
                break
            if index[n]!=-1:
                temp.random = List[index[n]]
            temp = temp.next
            n += 1
        if index[n]!=-1:
            temp.random = List[index[n]]
        return result

2.K神的哈希表解法，妙哉妙哉。建一个空字典，然后把原链表的节点：复制的节点，这样的键值对放入字典里。因为所有的新节点都在字典里了，所以就可以直接连next和random了。

class Solution:
    def copyRandomList(self, head: 'Node') -> 'Node':
        if not head: return
        dic = {}
        cur = head
        while cur:
            dic[cur] = Node(cur.val)
            cur = cur.next
        
        cur = head
        while cur:
            dic[cur].next = dic.get(cur.next)
            dic[cur].random = dic.get(cur.random)
            cur = cur.next
        return dic[head]

3（后补）. md，面试遇到这道题了，然后我只会hash，完全不知道还有这一种解法。简单来说就是拼接+拆分。一张图足以说明思路。
在这里插入图片描述

class Solution:
    def copyRandomList(self, head: 'Node') -> 'Node':
        if not head: return
        node = head
        while node:
            temp = Node(node.val)
            temp.next = node.next
            node.next = temp
            node = temp.next
        node = head
        while node:
            if node.random:
                node.next.random = node.random.next
            node = node.next.next
        pre = head
        cur = head.next
        result = head.next
        while cur.next:
            pre.next = cur.next
            cur.next = cur.next.next
            pre = pre.next
            cur = cur.next
        pre.next = None
        return result

自我反思： 一种题一定要掌握多种解法。

剑指36.二叉搜索树与双向链表

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。

为了让您更好地理解问题，以下面的二叉搜索树为例：
在这里插入图片描述
我们希望将这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个前驱和后继指针。对于双向循环链表，第一个节点的前驱是最后一个节点，最后一个节点的后继是第一个节点。

下图展示了上面的二叉搜索树转化成的链表。“head” 表示指向链表中有最小元素的节点。
在这里插入图片描述
特别地，我们希望可以就地完成转换操作。当转化完成以后，树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继。还需要返回链表中的第一个节点的指针。

1.又看了一下自己的方法，好像这样不算就地。我是先中序遍历，把所有node放进了一个列表里，然后相邻相连，首尾相连。

class Solution:
    def treeToDoublyList(self, root: 'Node') -> 'Node':
        if not root:
            return
        seq = self.recursion(root)
        l = len(seq)
        for i in range(l):
            seq[i].right = seq[(i+1)%l]
            seq[i].left = seq[(i-1)%l]
        return seq[0]
    def recursion(self,node):
        if node == None:
            return []
        return self.recursion(node.left)+[node]+self.recursion(node.right)

2.真正的原地算法，在递归的过程中，直接把cur和pre连起来，最后再连head和尾节点pre。

class Solution:
    def treeToDoublyList(self, root: 'Node') -> 'Node':
        def dfs(cur):
            if not cur: return
            dfs(cur.left)
            if self.pre:
                self.pre.right, cur.left = cur, self.pre
            else:
                self.head = cur
            self.pre = cur
            dfs(cur.right)
        
        if not root: return
        self.pre = None
        dfs(root)
        self.head.left, self.pre.right = self.pre, self.head
        return self.head

**自我反思：**第一次做的时候没注意到原地算法，下次还是得注意。

剑指37.序列化二叉树

请实现两个函数，分别用来序列化和反序列化二叉树。

示例:
你可以将以下二叉树：

序列化为 “[1,2,3,null,null,4,5]”

1.好像又写得有点长。序列化就是bfs，反序列化就是从序列的第一位出发，作为根节点，然后后面的两位作为他的叶子。同时借助stack，一行一行的处理。

class Codec:

    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        if not root:
            return []
        stack = [root]
        temp = []
        result = []
        while stack:
            node = stack.pop()
            if node:
                result.append(node.val)
                temp.insert(0,node.left)
                temp.insert(0,node.right)
            else:
                result.append(None)
            if stack == []:
                stack = temp
                temp = []
        while result[-1]==None:
            result.pop()
        return result
    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        if not data:
            return
        root = TreeNode(data[0])
        data.pop(0)
        stack = [root]
        while data:
            node = stack.pop(0)
            if data[0]!=None:
                node.left = TreeNode(data[0])
                stack.append(node.left)
            data.pop(0)
            if len(data)>=1:
                if data[0]!=None:
                    node.right = TreeNode(data[0])
                    stack.append(node.right)
                data.pop(0)
            else:
                break
        return root

**自我反思：**同样看了一下K神的代码，虽然大家思路一致，但是写的确实要更清晰一些，这里偷个小懒，就不抄答案了。

fantastic_bobo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
剑指offer思路整理（个人向）31-37

剑指31.栈的压入、弹出序列输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。示例 1：输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]输出：true解释：我们可以按以下顺序执行：push(1), push(2), p
复制链接

扫一扫