LeetCode力扣刷题——指针三剑客之二:树


一、数据结构介绍

        作为(单)链表的升级版,我们通常接触的树都是二叉树(binary tree),即每个节点最多有 两个子节点;且除非题目说明,默认树中不存在循环结构。LeetCode 默认的树表示方法如下。

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

        可以看出,其与链表的主要差别就是多了一个子节点的指针。


二、经典问题

1. 树的递归

        对于一些简单的递归题,某些 LeetCode 达人喜欢写 one-line code,即用一行代码解决问题, 把 if-else 判断语句压缩成问号冒号的形式。我们也会展示一些这样的代码,但是对于新手,笔者仍然建议您使用 if-else 判断语句。

        在很多时候,树递归的写法与深度优先搜索的递归写法相同,因此本书不会区分二者。

104. 二叉树的最大深度

104. Maximum Depth of Binary Tree

        给定一个二叉树,找出其最大深度。

        二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

        说明: 叶子节点是指没有子节点的节点。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        return root? 1 + max(maxDepth(root->left), maxDepth(root->right)): 0;
    }
};

110. 平衡二叉树

110. Balanced Binary Tree

        给定一个二叉树,判断它是否是高度平衡的二叉树。

        本题中,一棵高度平衡二叉树定义为:一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

        解法类似于求树的最大深度,但有两个不同的地方:一是我们需要先处理子树的深度再进行 比较,二是如果我们在处理子树时发现其已经不平衡了,则可以返回一个-1,使得所有其长辈节 点可以避免多余的判断(本题的判断比较简单,做差后取绝对值即可;但如果此处是一个开销较 大的比较过程,则避免重复判断可以节省大量的计算时间)。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isBalanced(TreeNode* root) {
        return helper(root) != -1;
    }
    int helper(TreeNode* root){
        if(!root){
            return 0;
        }
        int left = helper(root->left), right = helper(root->right);
        if(left == -1 || right == -1 || abs(left - right) > 1){
            return -1;
        }
        return 1 + max(left, right);
    }
};

543. 二叉树的直径

543. Diameter of Binary Tree

        给定一棵二叉树,你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。

        注意:两结点之间的路径长度是以它们之间边的数目表示。

        同样的,我们可以利用递归来处理树。解题时要注意,在我们处理某个子树时,我们更新的 最长直径值和递归返回的值是不同的。这是因为待更新的最长直径值是经过该子树根节点的最长直径(即两侧长度);而函数返回值是以该子树根节点为端点的最长直径值(即一侧长度),使用这样的返回值才可以通过递归更新父节点的最长直径值)。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    // 主函数
    int diameterOfBinaryTree(TreeNode* root) {
        int diameter = 0;
        depth(root, diameter);
        return diameter;
    }
    // 辅函数 - 深度递归
    int depth(TreeNode* node, int& diameter){
        if(!node)   return 0;
        int  l = depth(node->left, diameter), r = depth(node->right, diameter);
        diameter = max(l + r, diameter); // 更新直径长度
        return 1 + max(l, r); // 返回深度
    }
};

437. 路径总和 III

437. Path Sum III

        给定一个二叉树的根节点 root ,和一个整数 targetSum ,求该二叉树里节点值之和等于 targetSum 的 路径 的数目。

        路径 不需要从根节点开始,也不需要在叶子节点结束,但是路径方向必须是向下的(只能从父节点到子节点)。

        递归每个节点时,需要分情况考虑:(1)如果选取该节点加入路径,则之后必须继续加入连 续节点,或停止加入节点(2)如果不选取该节点加入路径,则对其左右节点进行重新进行考虑。 因此一个方便的方法是我们创建一个辅函数,专门用来计算连续加入节点的路径。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    // 主函数
    int pathSum(TreeNode* root, int targetSum) {
        if(!root)   return 0;
        return pathSumStartWithRoot(root, targetSum) + pathSum(root->left, targetSum) + pathSum(root->right, targetSum);
    }
    // 辅函数 - 对当前节点连续加入节点,判断是否满足
    long long pathSumStartWithRoot(TreeNode* root, long long targetSum){
        if(!root)   return 0;
        long long count = root->val == targetSum? 1: 0;
        count += pathSumStartWithRoot(root->left, targetSum - root->val);
        count += pathSumStartWithRoot(root->right, targetSum - root->val);
        return count;
    }
};

101. 对称二叉树

101. Symmetric Tree

        给你一个二叉树的根节点 root , 检查它是否轴对称。

        判断一个树是否对称等价于判断左右子树是否对称。笔者一般习惯将判断两个子树是否相等 或对称类型的题的解法叫做“四步法”:(1)如果两个子树都为空指针,则它们相等或对称(2) 如果两个子树只有一个为空指针,则它们不相等或不对称(3)如果两个子树根节点的值不相等, 则它们不相等或不对称(4)根据相等或对称要求,进行递归处理。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(!root)   return true;
        return helper(root->left, root->right);
    }
    bool helper(TreeNode* left, TreeNode* right){
        if(!left && !right) return true;
        if(!left || !right) return false;
        if(left->val != right->val) return false;
        return helper(left->left, right->right) && helper(left->right, right->left);
    }
};

1110. 删点成林

1110. Delete Nodes And Return Forest

        给出二叉树的根节点 root,树上每个节点都有一个不同的值。

        如果节点值在 to_delete 中出现,我们就把该节点从树上删去,最后得到一个森林(一些不相交的树构成的集合)。

        返回森林中的每棵树。你可以按任意顺序组织答案。

        这道题最主要需要注意的细节是如果通过递归处理原树,以及需要在什么时候断开指针。同 时,为了便于寻找待删除节点,可以建立一个哈希表方便查找。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector delNodes(TreeNode* root, vector& to_delete) {
        vectorforest;
        unordered_set dict(to_delete.begin(), to_delete.end());
        root = helper(root, dict, forest);
        // 自下而上最顶点的节点是处理不到,所以递归完后需要对最顶点的节点做处理 
        if(root){
            forest.push_back(root);
        }
        return forest;
    }

    TreeNode* helper(TreeNode* root, unordered_set &dict, vector &forest){
        if(!root)   return root;
        // 先进行递归操作,目的是自下而上对树进行操作,即树的后序遍历
        root->left = helper(root->left, dict, forest);
        root->right = helper(root->right, dict, forest);
        // 如果存在一个节点的val值存在于to_delete数组中
        if(dict.count(root->val)){
            // 把当前的左右子树压入forest数组中
            if(root->left){
                forest.push_back(root->left);
            }
            if(root->right){
                forest.push_back(root->right);
            }
            root = nullptr; // 删除当前节点
        }
        return root;
    }
    
};

2. 层次遍历

        我们可以使用广度优先搜索进行层次遍历。注意,不需要使用两个队列来分别存储当前层的 节点和下一层的节点,因为在开始遍历一层的节点时,当前队列中的节点数就是当前层的节点 数,只要控制遍历这么多节点数,就能保证这次遍历的都是当前层的节点。

637. 二叉树的层平均值

637. Average of Levels in Binary Tree

        给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10^-5 以内的答案可以被接受。

        利用广度优先搜索,我们可以很方便地求取每层的平均值。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector averageOfLevels(TreeNode* root) {
        vector ans;
        if(!root)   return ans;
        queue q;
        q.push(root);
        while(!q.empty()){
            int count = q.size();
            double sum = 0;
            for(int i=0; ival;
                if(node->left){
                    q.push(node->left);
                }
                if(node->right){
                    q.push(node->right);
                }
            }
            ans.push_back(sum / count);
        }
        return ans;
    }
};

2. 前中后序遍历

        前序遍历、中序遍历和后序遍历是三种利用深度优先搜索遍历二叉树的方式。它们是在对节 点访问的顺序有一点不同,其它完全相同。考虑如下一棵树:

LeetCode力扣刷题——指针三剑客之二:树_第1张图片

         前序遍历先遍历父结点,再遍历左结点,最后遍历右节点,我们得到的遍历顺序是 [1 2 4 5 3 6]。

void preorder(TreeNode *root){
    visit(root);
    preorder(root->left);
    preorder(root->right);
}

        中序遍历先遍历左节点,再遍历父结点,最后遍历右节点,我们得到的遍历顺序是 [4 2 5 1 3 6]。

void inorder(TreeNode *root){
    inorder(root->left);
    visit(root);
    inorder(root->right);
}

        后序遍历先遍历左节点,再遍历右结点,最后遍历父节点,我们得到的遍历顺序是 [4 5 2 6 3 1]。

void postorder(TreeNode *root){
    postorder(root->left);
    postorder(root->right); 
    visit(root);
}

105. 从前序与中序遍历序列构造二叉树

105. Construct Binary Tree from Preorder and Inorder Traversal

        给定两个整数数组 preorder 和 inorder ,其中 preorder 是二叉树的先序遍历, inorder 是同一棵树的中序遍历,请构造二叉树并返回其根节点。

对于任意一颗树而言,前序遍历的形式总是:
        [ 根节点, [左子树的前序遍历结果], [右子树的前序遍历结果] ]


即根节点总是前序遍历中的第一个节点。而中序遍历的形式总是:
        [ [左子树的中序遍历结果], 根节点, [右子树的中序遍历结果] ]

LeetCode力扣刷题——指针三剑客之二:树_第2张图片

         我们通过本题的样例讲解一下本题的思路。前序遍历的第一个节点是 4,意味着 4 是根节点。 我们在中序遍历结果里找到 4 这个节点,根据中序遍历的性质可以得出,4 在中序遍历数组位置 的左子数组为左子树,节点数为 1,对应的是前序排列数组里 4 之后的 1 个数字(9);4 在中序 遍历数组位置的右子数组为右子树,节点数为 3,对应的是前序排列数组里最后的 3 个数字。有了这些信息,我们就可以对左子树和右子树进行递归复原了。为了方便查找数字的位置,我们可以用哈希表预处理中序遍历的结果。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    unordered_map index;
public:
    TreeNode* buildTree(vector& preorder, vector& inorder) {
        int n = preorder.size();
        // 构造哈希映射,帮助我们快速定位根节点
        for(int i=0; i& preorder, const vector& inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right){
        if(preorder_left > preorder_right){
            return nullptr;
        }
        // 前序遍历中的第一个节点就是根节点
        int preorder_root = preorder_left;
        // 在中序遍历中定位根节点
        int inorder_root = index[preorder[preorder_root]];
        // 先把根节点建立出来
        TreeNode* root = new TreeNode(preorder[preorder_root]);
        // 得到左子树中的节点数目
        int size_left_subtree = inorder_root - inorder_left;
        // 递归地构造左子树,并连接到根节点
        // 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
        root->left = buildTreeHelper(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1);
        // 递归地构造右子树,并连接到根节点
        // 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
        root->right = buildTreeHelper(preorder, inorder, preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right);

        return root;
    }
};

144. 二叉树的前序遍历

144. Binary Tree Preorder Traversal

        给你二叉树的根节点 root ,返回它节点值的 前序 遍历。

        因为递归的本质是栈调用,因此我们可以通过栈来实现前序遍历。注意入栈的顺序。

递归写法:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector preorderTraversal(TreeNode* root) {
        vector ans;
        helper(root, ans);
        return ans;
    }
    void helper(TreeNode* root, vector& ans){
        if(!root){
            return;
        }
        ans.push_back(root->val);
        helper(root->left, ans);
        helper(root->right, ans);
    }
};

栈写法:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

class Solution {
public:
    vector preorderTraversal(TreeNode* root) {
        vector ans;
        if(!root)   return ans;
        stack s;
        s.push(root);
        while(!s.empty()){
            TreeNode* node = s.top();
            s.pop();
            ans.push_back(node->val);
            if(node->right){
                s.push(node->right);
            }
            if(node->left){
                s.push(node->left);
            }
        }
        return ans;
    }
};

3. 二叉查找树

        二叉查找树(Binary Search Tree, BST)是一种特殊的二叉树:对于每个父节点,其左子树中 所有节点的值小于等于父结点的值,其右子树中所有节点的值大于等于父结点的值。因此对于一 个二叉查找树,我们可以在 O(log n) 的时间内查找一个值是否存在:从根节点开始,若当前节点 的值大于查找值则向左下走,若当前节点的值小于查找值则向右下走。同时因为二叉查找树是有 序的,对其中序遍历的结果即为排好序的数组。

        一个二叉查找树的实现如下。

LeetCode力扣刷题——指针三剑客之二:树_第3张图片

template 
class BST{
    struct Node{
        T data;
        Node* left;
        Node* right;
    }

    Node* root;

    Node* makeEmpty(Node* t){
        if(t == NULL)    return NULL;
        makeEmpty(t->left);
        makeEmpty(t->right);
        delete t;
        return NULL;
    }

    Node* insert(Node* t, T x){
        if(t == NULL){
            t = new Node;
            t->data = x;
            t->left = t->right = NULL;
        }else if(x < t->data){
            t->left = insert(t->left, x);
        }else if(x > t->data){
            t->right = insert(t->right, x);
        }
        return t;
    }

    Node* find(Node* t, T x){
        if(t == NULL)   return NULL;
        if(x < t->data) return find(t->left, x);
        if(x > t->data) return find(t->right, x);
        return t;
    }

    Node* findMin(Node* t){
        if(t == NULL || t->left == NULL)    return t;
        return findMin(t->left);
    }

    Node* findMax(Node* t){
        if(t == NULL || t->right == NULL)    return t;
        return findMax(t->right);
    }

    Node* remove(Node* t ,T x){
        Node* temp;
        if(t == NULL){
            return NULL;
        }else if(x < t->data){
            t->left = remove(t->left, x);
        }else if(x > t->data){
            t->right = return(t->right, x);
        }else if(t->left && t->right){
            temp = findMin(t->right);
            t->data = temp->data;
            t->right = remove(t->right, t->data);
        }else{
            temp = t;
            if(t->left == NULL){
                t = t->right;
            }else if(t->right == NULL){
                t = t->left;
            }
            delete temp;
        }
        return t;
    }

public:
    BST(): root(NULL){}

    ~BST(){
        root = makeEmpty(root);
    }

    void insert(T x){
        insert(root, x);
    }

    void remove(T x){
        remove(root, x);
    }
};

99. 恢复二叉搜索树

99. Recover Binary Search Tree

        给你二叉搜索树的根节点 root ,该树中的 恰好 两个节点的值被错误地交换。请在不改变其结构的情况下,恢复这棵树 

        我们可以使用中序遍历这个二叉查找树,同时设置一个 prev 指针,记录当前节点中序遍历 时的前节点。如果当前节点小于 prev 节点的值,说明需要调整次序。

        有一个技巧是如果遍历整个序列过程中只出现了一次次序错误,说明就是这两个相邻节点需要被交换;如果出现了两次次序错误,那就需要交换这两个节点。

class Solution {
public:
    void recoverTree(TreeNode* root) {
        TreeNode *mistake1 = nullptr, *mistake2 = nullptr, *prev = nullptr;
        inorder(root, mistake1, mistake2, prev);
        if(mistake1 && mistake2){
            int temp = mistake1->val;
            mistake1->val = mistake2->val;
            mistake2->val = temp;
        }
    }
    void inorder(TreeNode* root, TreeNode* &mistake1, TreeNode* &mistake2, TreeNode* &prev){
        if(!root)   return;
        if(root->left){
            inorder(root->left, mistake1, mistake2, prev);
        }
        if(prev && root->val < prev->val){
            if(!mistake1){
                mistake1 = prev;
                mistake2 = root;
            }else{
                mistake2 = root;
            }
        }
        prev = root;
        if(root->right){
            inorder(root->right, mistake1, mistake2, prev);
        }
    }
};

669. 修剪二叉搜索树

669. Trim a Binary Search Tree

        给你二叉搜索树的根节点 root ,同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树,使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即,如果没有被移除,原有的父代子代关系都应当保留)。 可以证明,存在 唯一的答案 。

        所以结果应当返回修剪好的二叉搜索树的新的根节点。注意,根节点可能会根据给定的边界发生改变。

        利用二叉查找树的大小关系,我们可以很容易地利用递归进行树的处理。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if(!root){
            return root;
        }
        if(root->val > high){
            return trimBST(root->left, low, high);
        }
        if(root->val < low){
            return trimBST(root->right, low, high);
        }
        root->left = trimBST(root->left, low, high);
        root->right = trimBST(root->right, low, high);
        return root;
    }
};

4. 字典树

        字典树/前缀树(Trie)用于判断字符串是否存在或者是否具有某种字符串前缀。

LeetCode力扣刷题——指针三剑客之二:树_第4张图片 字典树,存储了单词 A、to、tea、ted、ten、i、in 和 inn,以及它们的频率

         为什么需要用字典树解决这类问题呢?假如我们有一个储存了近万个单词的字典,即使我们 使用哈希,在其中搜索一个单词的实际开销也是非常大的,且无法轻易支持搜索单词前缀。然而 由于一个英文单词的长度 n 通常在 10 以内,如果我们使用字典树,则可以在 O(n)——近似 O(1) 的时间内完成搜索,且额外开销非常小。

208. 实现 Trie (前缀树)

208. Implement Trie (Prefix Tree)

        Trie(发音类似 "try")或者说 前缀树 是一种树形数据结构,用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景,例如自动补完和拼写检查。

请你实现 Trie 类:

        Trie() 初始化前缀树对象。
        void insert(String word) 向前缀树中插入字符串 word 。
        boolean search(String word) 如果字符串 word 在前缀树中,返回 true(即,在检索之前已经插入);否则,返回 false 。
        boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ,返回 true ;否则,返回 false 。

        以下是字典树的典型实现方法。

class TrieNode{
public:
    TrieNode* childNode[26];
    bool isVal;
    TrieNode(): isVal(false) {
        for(int i=0; i<26; ++i){
            childNode[i] = nullptr;
        }
    }
};

class Trie {
    TrieNode* root;
public:
    Trie(): root(new TrieNode()) {

    }

    // 向字典树插入一个词
    void insert(string word) {
        TrieNode* temp = root;
        for(int i=0; ichildNode[word[i] - 'a']){
                temp->childNode[word[i] - 'a'] = new TrieNode();
            }
            temp = temp->childNode[word[i] - 'a'];
        }
        temp->isVal = true;
    }
    
    // 判断字典树里是否有一个词
    bool search(string word) {
        TrieNode* temp = root;
        for(int i=0; ichildNode[word[i] - 'a'];
        }
        return temp? temp->isVal: false;
    }
    
    // 判断字典树是否有一个以词开始的前缀
    bool startsWith(string prefix) {
        TrieNode* temp = root;
        for(int i=0; ichildNode[prefix[i] - 'a'];
        }
        return temp;
    }
};

/**
 * Your Trie object will be instantiated and called as such:
 * Trie* obj = new Trie();
 * obj->insert(word);
 * bool param_2 = obj->search(word);
 * bool param_3 = obj->startsWith(prefix);
 */

三、巩固练习


欢迎大家共同学习和纠正指教

你可能感兴趣的:(LeetCode,数据结构与算法——经典题目,每日一练:经典算法题,leetcode,算法,树,c++,数据结构)