1.递增顺序查找树
难度：简单
给定一个树，按中序遍历重新排列树，使树中最左边的结点现在是树的根，并且每个结点没有左子结点，只有一个右子结点。
示例 ：
输入：[5,3,6,2,4,null,8,1,null,null,null,7,9]
5
/ \
3 6
/ \ \
2 4 8
/ / \
1 7 9
输出：[1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]
1
\
2
\
3
\
4
\
5
\
6
\
7
\
8
\
9
提示：
给定树中的结点数介于 1 和 100 之间。
每个结点都有一个从 0 到 1000 范围内的唯一整数值。
思路：中序遍历得到树的元素(可用迭代也可用递归)，保存在数组中，然后创建新的树。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* increasingBST(TreeNode* root) {
vector<int> valSet;
stack<TreeNode*> stack;
while(root || !stack.empty()){ //迭代求得中序遍历
while(root){
stack.push(root);
root=root->left;
}
if(!stack.empty()){
valSet.push_back(stack.top()->val);
root=stack.top()->right;
stack.pop();
}
}
TreeNode* increBST=new TreeNode(valSet[0]);
TreeNode* tempBST= increBST;
for(int i=1;i<valSet.size();i++){
tempBST->right=new TreeNode(valSet[i]);
tempBST=tempBST->right;
}
return increBST;
}
};
改用递归，其实时间是差不多的，基本上一样
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* increasingBST(TreeNode* root) {
vector<int> tempVal;
inorderTraversal(root,tempVal);
TreeNode* increBST=new TreeNode(tempVal[0]); //注意这里需要new一个空间
TreeNode* tempBST= increBST;
for(int i=1;i<tempVal.size();i++){
tempBST->right=new TreeNode(tempVal[i]); //new 一个空间
tempBST=tempBST->right;
}
return increBST;
}
void inorderTraversal(TreeNode* root,vector<int> &tempVal){ //递归中序遍历得到树的元素
if(root->left!=NULL){//遍历左子树
inorderTraversal(root->left,tempVal);
}
tempVal.push_back(root->val);//记录根节点
if(root->right!=NULL){//遍历右子树
inorderTraversal(root->right,tempVal);
}
}
};
2.求根到叶子节点之和
难度：中等
给定一个二叉树，它的每个结点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字。
例如，从根到叶子节点路径 1->2->3 代表数字 123。
计算从根到叶子节点生成的所有数字之和。
说明: 叶子节点是指没有子节点的节点。
示例 1:
输入: [1,2,3]
1
/ \
2 3
输出: 25
解释:
从根到叶子节点路径 1->2 代表数字 12.
从根到叶子节点路径 1->3 代表数字 13.
因此，数字总和 = 12 + 13 = 25.
示例 2:
输入: [4,9,0,5,1]
4
/ \
9 0
/ \
5 1
输出: 1026
解释:
从根到叶子节点路径 4->9->5 代表数字 495.
从根到叶子节点路径 4->9->1 代表数字 491.
从根到叶子节点路径 4->0 代表数字 40.
因此，数字总和 = 495 + 491 + 40 = 1026.
思路：很典型的一道题，也就是将每条路径上的元素转成string类型然后串联起来，到达叶子节点后转换成int类型push_back到容器中，再求和就行了，主要用到了递归实现深度优先搜索。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int sumNumbers(TreeNode* root) {
if(root==NULL) return 0;
vector<int> savePath;
string str="";
getSubPath(root,savePath,str);
int sumNumber=0;
vector<int>::iterator iter = savePath.begin();
while (iter != savePath.end()){
sumNumber += *iter++;
}
return sumNumber;
}
void getSubPath(TreeNode* root, vector<int> &savePath, string str){
str+=to_string(root->val);
if(root->left==NULL && root->right==NULL) {
savePath.push_back(stoi(str));
}
if(root->left!=NULL){
getSubPath(root->left,savePath,str); //递归
}
if(root->right!=NULL){
getSubPath(root->right,savePath,str);
}
}
};
3.验证二叉树
难度：中等
给定一个二叉树，判断其是否是一个有效的二叉搜索树。
假设一个二叉搜索树具有如下特征：
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1:
输入:
2
/ \
1 3
输出: true
示例 2:
输入:
5
/ \
1 4
/ \
3 6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
根节点的值为 5 ，但是其右子节点值为 4 。
思路：递归的函数用得很巧，参考网上大神的。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isValidBST(TreeNode* root) {
return isValidBST(root, LONG_MIN, LONG_MAX);
}
bool isValidBST(TreeNode *root, long mn, long mx) { //这个函数用得很巧
if (!root) return true;
if (root->val <= mn || root->val >= mx) return false;
return isValidBST(root->left, mn, root->val) && isValidBST(root->right, root->val, mx);
}
};
