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教程