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