LeetCode--树

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

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;
    }
};

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

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

   1
    
     2
    /
   3

返回[3,2,1]。

注意：递归解决方案很简单，你可以迭代地做吗？

思路：

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

/**
 * 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;
    }
};

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

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

   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;
    }
};

4、给定包含从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);
    }
};

5、跟进问题“在每个节点中填充下一个右指针”。
如果给定的树可以是任何二叉树怎么办？ 您以前的解决方案是否仍然可行
注意：
您可能只使用恒定的额外空间。
例如，
鉴于以下二叉树，
         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;
        }
    }
};

6、给出一棵二叉树
     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;
        }
    }
};

8、给定二叉树和求和，找到所有根到叶路径，其中每个路径的总和等于给定的总和。
例如：
给出下面的二叉树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);
    }
};

9、给定二叉树和求和，确定树是否具有根到叶路径，使得沿路径的所有值相加等于给定的总和。

例如：
给出下面的二叉树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);
    }
};