剑指offer+leetcode刷题记录

剑指offer

树的子结构-常考

题目描述

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

思路：

考虑使用递归完成，一个函数嵌套递归判断是否匹配到起始节点；另写一个递归，判断左子树和右子树是否为子结构的函数。

1. 判断A当前节点开始，B是否为子结构，如果不是看下A的左子树节点，如果也不是再看下A的右子树。
2. 如果是某节点开始A与B的起始节点重合：
   • 判断B是否匹配完了，如果匹配完了说明为子结构
   • 如果A匹配完了，或者A的值和B和值不等，直接返回False
   • 如果当前点相同，那同时看一下左子树和右子树的情况。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def HasSubtree(self, pRoot1, pRoot2):
        # write code here
        if not pRoot1 or not pRoot2:
            return False
        # 后面是hasssubtree 函数self要加上
        return self.is_subtree(pRoot1,pRoot2) or self.HasSubtree(pRoot1.left,pRoot2) or self.HasSubtree(pRoot1.right,pRoot2)
    
    def is_subtree(self,A,B):
        
        if not B:
            return True
        
        if not A or A.val != B.val:
            return False
        ## 没有return self.is_subtree(A,B)
        return self.is_subtree(A.left,B.left) and self.is_subtree(A.right,B.right)

二叉树的镜像

题目描述

操作给定的二叉树，将其变换为源二叉树的镜像。

输入描述

思路：
还是用递归，依次对每个非叶节点进行翻转。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if not root:
            return None
        # right漏了个h
        root.left,root.right = root.right,root.left
        if root.left:
            self.Mirror(root.left)
            
        if root.right:
            self.Mirror(root.right)

顺时针打印矩阵

题目描述

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

思路：
先转置再上下翻转

# -*- coding:utf-8 -*-

class Solution(object):
    # matrix类型为二维列表，需要返回列表
    def printMatrix(self, matrix):
        res = []
        
        """
        zip(*matrix)
        (5, 9, 13)
        (6, 10, 14)
        (7, 11, 15)
        (8, 12, 16)
        """
        while matrix:
            res += matrix.pop(0)
            matrix = list(map(list,zip(*matrix)))[::-1]
            
        return res
        
if __name__ == '__main__':
    
    s = Solution()
    
    m = int(input())
    n = int(input())
    matrix = [[0]*n]*m
    
    for i in range(m):
        matrix[i] = input().split()
        matrix[i] = [int(j) for j in matrix[i]]
        
    print(s.printMatrix(matrix))

包含min函数的栈

题目描述

设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。

• push(x) – 将元素 x 推入栈中。
• pop() – 删除栈顶的元素。
• top() – 获取栈顶元素。
• getMin() – 检索栈中的最小元素。
  示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.getMin();   --> 返回 -2.

思路：

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.stack = []
        self.minstack = []
        
    def push(self, node):
        self.stack.append(node)
        if len(self.minstack) == 0 or node <= self.minstack[-1]:
            self.minstack.append(node)
            
    def pop(self):
        top = self.stack.pop()
        if len(self.minstack) >0 and top == self.minstack[-1]:
            self.minstack.pop()
        
    def top(self):
        # 注意加个判断
        if self.stack:
            return self.stack[-1]
    def min(self):
        # 注意加个判断
        if self.minstack:
            return self.minstack[-1]

栈的压入、弹出

题目描述

给定 pushed 和 popped 两个序列，每个序列中的 值都不重复，只有当它们可能是在最初空栈上进行的推入 push 和弹出 pop 操作序列的结果时，返回 true；否则，返回 false 。

示例 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

示例 2：

输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
输出：false
解释：1 不能在 2 之前弹出。

思路：

# -*- coding:utf-8 -*-
class Solution:
    def IsPopOrder(self, pushV, popV):
        j = 0
        stack= []
        for i in pushV:
            stack.append(i)
            while stack and j < len(popV) and stack[-1] == popV[j]:
                stack.pop()
                j+=1
                
        return j == len(popV)

从上往下打印二叉树

题目描述

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

思路：
其实就是广度优先遍历二叉树。可以借助于一个队列实现。每次打印一个节点，并判断该节点的左右节点是否存在，如果存在则将它们依次放入队列的尾部，并从队列的头部开始重复上述操作。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def PrintFromTopToBottom(self, root):
        res = []
        
        if not root:
            return res
        
        queue = [root]
        while queue:
            cur = queue.pop(0)
            res.append(cur.val)
            if cur.left:
                queue.append(cur.left)
            if cur.right:
                queue.append(cur.right)
                
        return res

二叉搜索树的后序遍历序列

题目描述

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

• 二叉搜索树，左子树上所有结点都小于根结点，右子树所有结点的值均大于它的根结点的值。
• 后序遍历：左儿子 -> 右儿子 -> 根结点

思路：
1、空树是False
2、列表最后一个树是根结点、找到第一个比根结点大的结点的索引
分成左子树和右子树，后面找到比根结点小的树是False:

# -*- coding:utf-8 -*-
class Solution:
    def VerifySquenceOfBST(self, sequence):
        if not sequence:
            return False
        
        cur = sequence[-1]
        del sequence[-1]
        index = None
        for i in range(len(sequence)):
            if index == None and sequence[i] > cur:
                index = i
            if index != None and sequence[i] < cur:
                return False
        if not sequence[:index]:
            left = True
        else:
            left = self.VerifySquenceOfBST(sequence[:index])
            
        if not sequence[index:]:
            right = True
        else:
            right = self.VerifySquenceOfBST(sequence[index:])
        return left and right

leetcode