LeetCode--树

时间  2019-11-08
标签 leetcode 繁體版
原文   原文链接

一、给定二叉树，找到它的最小深度。最小深度是从根节点到最近叶节点的最短路径上的节点数。函数

class Solution {
public:
    int run(TreeNode *root) {
        if(!root) return 0;
        queue<TreeNode*> qu;
        TreeNode *last;
        TreeNode *now;
        int level=1;
        int size;
        last = now = root;
        qu.push(root);
        while(qu.size()){
            now = qu.front();
            qu.pop();
            size = qu.size();
            if(now->left) qu.push(now->left);
            if(now->right) qu.push(now->right);
            if(qu.size()-size ==0) break;
            if(last == now){
                level++;
                if(qu.size()) last = qu.back();
            }
        }
        return level;
    }
};

二、给定二叉树，返回其节点值的后序遍历。post

例如：
给定二叉树{1，＃，2,3}，spa

   1
    \
     2
    /
   3指针

返回[3,2,1]。code

注意：递归解决方案很简单，你能够迭代地作吗？blog

思路：递归

前序遍历 根->左->右 变成 根->右->左 结果再reverse一下it

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode *root) {
        vector<int> res;
        if(!root) return res;
        stack<TreeNode *> st;
        st.push(root);
        while(st.size()){
            TreeNode *temp = st.top();
            st.pop();
            res.push_back(temp->val);
            if(temp->left) st.push(temp->left);
            if(temp->right) st.push(temp->right);
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

三、给定二叉树，返回其节点值的前序遍历。io

例如：
给定二叉树{1，＃，2,3}，ast

   1
    \
     2
    /
   3

返回[1,2,3]。

注意：递归解决方案很简单，你能够迭代地作吗？

思路：

非递归方式求前序遍历

首先找根节点的左孩子，若是有则放入开辟好的栈里，若没有则找他的右孩子，

若此时没有其右孩子，则返回它的父节点，观察其是否有右兄弟，以此类推

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode *root) {
        vector<int> res;
        if(!root) return res;
        stack<TreeNode*> st;
        TreeNode *p = root;
        while(!st.empty() || p!=NULL){
            if(p!=NULL){  //若是有左孩子
                res.push_back(p->val); //将值放入到开辟好的容器中
                st.push(p); //将其放入栈中
                p = p->left; //继续找左孩子
            }else{
                p = st.top(); //找到当前栈中的最上层的节点
                st.pop(); //删除该节点
                p = p->right;  // 看这个节点是由由右孩子
            }
        }
        return res;
    }
};

四、给定包含从0到9的数字的二叉树，每一个根到叶路径能够表示数字。
一个例子是root-to-leaf path1-> 2-> 3，它表明数字123。
找到全部根到叶数的总和。
例如，
    1
    / \
   2 3

root-to-leaf path1-> 2表示数字12。
root-to-leaf path1-> 3表示数字13。
返回总和= 12 + 13 = 25。

思路：

先序遍历的思想(根左右)+数字求和(每一层都比上层和*10+当前根节点的值)

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int sumNumbers(TreeNode *root) {
        int sum=0;
        if(root==NULL) return sum;
        return preOrdersumNumber(root,sum);
    }
    int preOrdersumNumber(TreeNode *root,int sum){
        if(root==0) return 0;
        sum = sum*10+root->val;
        if(root->left==NULL && root->right==NULL){
            return sum;
        }
        return preOrdersumNumber(root->left,sum)+preOrdersumNumber(root->right,sum);
    }
};

五、跟进问题“在每一个节点中填充下一个右指针”。
若是给定的树能够是任何二叉树怎么办？ 您之前的解决方案是否仍然可行
注意：
您可能只使用恒定的额外空间。
例如，
鉴于如下二叉树，
         1
        / \
       2 3
      / \ \
     4 5 7
调用函数后，树应该以下所示：
          1 - > NULL
        / \
       2 - > 3 - > NULL
      / \ \
     4-> 5 - > 7 - > NULL

思路：

若是当前层全部结点的next 指针已经设置好了，那么据此，下一层全部结点的next指针 也能够依次被设置。

/**
 * Definition for binary tree with next pointer.
 * struct TreeLinkNode {
 *  int val;
 *  TreeLinkNode *left, *right, *next;
 *  TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
 * };
 */
class Solution {
public:
    void connect(TreeLinkNode *root) {
        while(root){
            TreeLinkNode *dummy = new TreeLinkNode(-1);
            TreeLinkNode *start;
            start = dummy;
            for(auto p=root;p;p=p->next){
                if(p->left){
                    start->next = p->left;
                    start = start->next;
                }
                if(p->right){
                    start->next = p->right;
                    start = start->next;;
                }
            }
            root = dummy->next;
        }
    }
};

六、给出一棵二叉树
     struct TreeLinkNode {
       TreeLinkNode * left;
       TreeLinkNode *权利;
       TreeLinkNode * next;
    }
填充每一个下一个指针以指向其下一个右侧节点。 若是没有下一个右节点，则应将下一个指针设置为NULL。
最初，全部下一个指针都设置为NULL。
注意：
您可能只使用恒定的额外空间。
您能够假设它是一个完美的二叉树（即，全部叶子都处于同一级别，而且每一个父级都有两个子级）。
例如，
鉴于如下完美的二叉树，
         1
        / \
       2 3
      / \ / \
     4 5 6 7
调用函数后，树应该以下所示：
          1 - > NULL
        / \
       2 - > 3 - > NULL
      / \ / \
     4-> 5-> 6-> 7 - > NULL

/**
 * Definition for binary tree with next pointer.
 * struct TreeLinkNode {
 *  int val;
 *  TreeLinkNode *left, *right, *next;
 *  TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
 * };
 */
class Solution {
public:
    void connect(TreeLinkNode *root) {
        while(root){
            TreeLinkNode *dummy = new TreeLinkNode(-1);
            TreeLinkNode *start;
            start = dummy;
            for(auto p=root;p;p=p->next){
                if(p->left){
                    start->next = p->left;
                    start = start->next;
                }
                if(p->right){
                    start->next = p->right;
                    start = start->next;;
                }
            }
            root = dummy->next;
        }
    }
};

八、给定二叉树和求和，找到全部根到叶路径，其中每一个路径的总和等于给定的总和。
例如：
给出下面的二叉树andsum = 22，
              五
              / \
             4 8
            / / \
           11 13 4
          / \ / \
         7 2 5 1
返回
[
   [5,4,11,2]
   [5,8,4,5]
]

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int> > pathSum(TreeNode *root, int sum) {
        vector<vector<int> > num;
        vector<int> array;
        pathSum(root,sum,array,num);
        return num;
    }
    void pathSum(TreeNode *root, int sum,vector<int> array,vector<vector<int> >& num){
        if(root==NULL) return;
        array.push_back(root->val);
        if(root->left==NULL && root->right==NULL && sum-root->val==0){
            num.push_back(array);
        }
        pathSum(root->left,sum-root->val,array,num);
        pathSum(root->right,sum-root->val,array,num);
    }
};

九、给定二叉树和求和，肯定树是否具备根到叶路径，使得沿路径的全部值相加等于给定的总和。

例如：
给出下面的二叉树andsum = 22，
              五
              / \
             4 8
            / / \
           11 13 4
          / \ \
         7 2 1
返回true，由于存在根到叶的路径5-> 4-> 11-> 2，其中和为22。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode *root, int sum) {
        if(root==NULL) return false;
        if(root->left==NULL && root->right==NULL && sum-root->val==0){
            return true;
        }
        return hasPathSum(root->left,sum-root->val) || hasPathSum(root->right,sum-root->val);
    }
};
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程