leetcode刷题之树

介绍

树是一种抽象数据类型（ADT）或是实现这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由 n(n>0) 个有限节点组成一个具有层次关系的集合。
它具有以下的特点：

1. 每个节点都只有有限个子节点或无子节点；
2. 没有父节点的节点称为根节点；
3. 每一个非根节点有且只有一个父节点；
4. 除了根节点外，每个子节点可以分为多个不相交的子树；
5. 树里面没有环路。

目录

• 二叉树
  1 递归执行前中后遍历
  2 非递归执行前中后遍历
  3 由遍历序列求二叉树
  4 完全二叉树
  5 节点最近公共祖先
• 字典树

一、二叉树

1. 递归执行前序，中序，后序遍历

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#前序遍历
class Solution:
	ans = []
    def preorderTraversal(self, root: TreeNode) -> List[int]:
            if root == None:
                return
            else:
            	self.ans.append(root.val)
                preorderTraversal(root.left)
                preorderTraversal(root.right)
#中序遍历
class Solution:
	ans = []
    def inorderTraversal(self, root: TreeNode) -> List[int]:
            if root == None:
                return
            else:
                inorderTraversal(root.left)
                self.ans.append(root.val)
                inorderTraversal(root.right)
#后序遍历
class Solution:
	ans = []
    def postTraversal(self, root: TreeNode) -> List[int]:
            if root == None:
                return
            else:
                postorderTraversal(root.left)
                self.ans.append(root.val)
                postorderTraversal(root.right)

2. 非递归执行前序，中序，后序遍历

这里介绍一个更加简洁易懂且通用的方式
其核心思想如下：
如果节点status = 1，则表示已经访问，将节点的值输出
如果节点status = 0，根据前序，中序，后序要求将该节点与左右子树以此入栈
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        ans = []
        stack = [(0, root)]
        while stack:
            status, node = stack.pop()
            if not node: continue
            if status == 0:
            #中序遍历
                stack.append((0, node.right))
                stack.append((1, node))
                stack.append((0, node.left))
            #前序遍历
                stack.append((0, node.right))
                stack.append((0, node.left))
                stack.append((1, node))
            #后序遍历
                stack.append((1, node))    
                stack.append((0, node.right))
                stack.append((0, node.left))           
            else:
                ans.append(node.val)
        return ans

3. 由遍历序列构造二叉树
   （1）从前序和中序遍历序列构造二叉树 和 从中序与后序遍历序列构造二叉树

根据一棵树的前序遍历与中序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，
前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：
    3
   / \
  9  20
    /  \
   15   7
思路:首先来看前序遍历和中序遍历的性质
前序遍历：遍历顺序为 父节点 -> 左子节点 -> 右子节点
中序遍历：遍历顺序为 左子节点 -> 父节点 -> 右子节点
步骤解析：首先通过前序遍历获取根节点，然后根据中序遍历将树分为左子树和右子树，重复上述过程。
注意在每次遍历过程中，为了保持递归一致性，左子树，右子树的中序遍历容易知道，而前序遍历怎么
求呢？
根据前序遍历性质可知左子节点大于右子节点，所以中序遍历获得的左子树的前序遍历也一定大于出现在
右子树之前，假设根节点在中序遍历中的位置是mid,则[1:mid + 1]为左子树在前序遍历中对应的节点，
也就是[mid + 1:]为右子树在前序遍历中对应的节点。
class Solution(object):
    def buildTree(self, preorder, inorder):
        if len(inorder) == 0:
            return None
        # 前序遍历第一个值为根节点
        root = TreeNode(preorder[0])
        # 因为没有重复元素，所以可以直接根据值来查找根节点在中序遍历中的位置
        mid = inorder.index(preorder[0])
        # 构建左子树
        root.left = self.buildTree(preorder[1:mid+1], inorder[:mid])
        # 构建右子树
        root.right = self.buildTree(preorder[mid+1:], inorder[mid+1:])
   
        return root
（2）同理可求，从中序与后序遍历序列构造二叉树     
class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
        def buildTree(inorder, postorder):
            if not inorder: return None
            root = TreeNode(postorder[-1])
            mid = inorder.index(postorder[-1])
            root.left = buildTree(inorder[0:mid], postorder[: mid])
            root.right = buildTree(inorder[mid + 1:], postorder[mid: -1])   
            return root
        return buildTree（inorder, postorder)

4. 完全二叉树
   说明：完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

举例一：完全二叉树的节点个数
给出一个完全二叉树，求出该树的节点个数。

示例:
输入: 
    1
   / \
  2   3
 / \  /
4  5 6
输出: 6
class Solution:
    def countNodes(self, root: TreeNode) -> int:
        def helper(root):
            if not root: return 0
            left, right = 0, 0
            if root.left: left = helper(root.left)
            if root.right: right = helper(root.right)
            return left + right + 1
        return helper(root)
    #精简版如下：
 	def countNodes(self, root: TreeNode) -> int:
 		return countNodes(root.left) + countNodes(root.right) + 1 if root else 0

5. 最近公共祖先
   给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
   百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。
思路：首先遍历整棵树的所有节点，找到节点p和q，然后包含p或q的树在上传过程中返回值为True，最深节点满足以下几种情况：
（1）当前节点为p或者q，且其子树中包含留一个节点
（2）当前节点不包括p或者q,其子树同时包含p和q
当我们由下向上回溯的过程中，第一次遇到一个节点满足以上两种其中任意一种情况，则该节点就是目标节点
class Solution:
    judge = None
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        def helper(root):
            if not root: return False
            left, right = False, False
            if root.left: left = helper(root.left)
            if root.right: right = helper(root.right)
            #情况（1）
            if (root == p or root == q) and (left or right):
                self.judge = root
                return False
            #情况（2）
            if left and right:  
                self.judge = root
                return False
            if root == p or root == q or left or right: return True
            
        helper(root)
        return self.judge

二、字典树
概念摘要：字典树又称为单词查找树，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。
前缀树的代码实现：

class Trie:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.lookup = {}

    def insert(self, word: str) -> None:
        """
        Inserts a word into the trie.
        """
        tree = self.lookup
        for a in word:
        	tree.setdefault(a, {})
            tree = tree[a]
        tree['#'] = "#"

    def search(self, word: str) -> bool:
        """
        Returns if the word is in the trie.
        """
        tree = self.lookup
        for a in word:
            if a not in tree.keys():
                return False
            tree = tree[a]
        if '#' in tree.keys():
            return True
        return False

    def startsWith(self, prefix: str) -> bool:
        """
        Returns if there is any word in the trie that starts with the given prefix.
        """
        tree = self.lookup
        for a in prefix:
            if a not in tree.keys():
                return False
            tree = tree[a]
        return True

举例二：添加单词与搜索单词

设计一个支持以下两种操作的数据结构：
void addWord(word)
bool search(word)


代码实现：
class WordDictionary:

    def __init__(self):
        self.word_dict = collections.defaultdict(list)

    def addWord(self, word):
        self.word_dict[len(word)] += [word]  #将单词长度作为键

    def search(self, word):
        length = len(word)
        def f(s, word):  #查找长度为length的集合里是否有word
            for i in range(length):
                if word[i] not in [s[i], '.']:
                    return False
            return True
        for w in self.word_dict[length]:
            if f(w, word):
                return True
        return False

举例三：恢复空格
哦，不！你不小心把一个长篇文章中的空格、标点都删掉了，并且大写也弄成了小写。像句子"I reset the computer. It still didn’t boot!“已经变成了"iresetthecomputeritstilldidntboot”。在处理标点符号和大小写之前，你得先把它断成词语。当然了，你有一本厚厚的词典dictionary，不过，有些词没在词典里。假设文章用sentence表示，设计一个算法，把文章断开，要求未识别的字符最少，返回未识别的字符数。

注意：本题相对原题稍作改动，只需返回未识别的字符数

class Solution {
	//----------------------------------前缀树类定义-------------------------------------------
    class Node{
        Node[] childs;
        boolean isWord;
        public Node(){
            childs = new Node[26];
            isWord = false;
        }
    }
    //----------------------------------构建前缀树---------------------------------------------
    public void buildTree(String word, Node root){
        Node temp = root;
        for(int i = 0; i<word.length(); i++){
            int index = word.charAt(i) - 'a';
            if(temp.childs[index] == null) temp.childs[index] = new Node();
            temp = temp.childs[index];
        }
        temp.isWord = true;
    }
    //------------------------------动态规划 + 前缀树--------------------------------------------
    public int respace(String[] dictionary, String sentence) {
        Node root = new Node();
        for(String s:dictionary){
            buildTree(s, root);
        }
        int len = sentence.length();
        int[] dp = new int[len + 1];
        //从后往前一次寻找子串对应的最小长度
        for(int i = len - 1; i>=0; i--){
            Node temp = root;
            dp[i] = len - i;//最不理想情况，当前子串不包含字典中单词
            for(int j = i; j<len; j++){
                int index = sentence.charAt(j) - 'a';
                //当前子串s前j个字符组成单词不在字典中，停止内循环
                if(temp.childs[index] == null) {dp[i] = Math.min(dp[i], j-i+1 + dp[j+1]); break;}
                //当前子串s前j个字符组成单词在字典中，s.substring(i, j+1) 对结果贡献为0
                if(temp.childs[index].isWord){dp[i] = Math.min(dp[i], dp[j+1]);}
                //当前子串s前j个字符在前缀树中，可以断句
                else{dp[i] = Math.min(dp[i], j-i+1 + dp[j+1]);}
                temp = temp.childs[index];
            }
        }
        return dp[0];

    }
}