LeetCode中一些树方面的题

// TreeTest.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include<iostream>
#include<vector>
#include<queue>
#include<string>
#include<map>
#include <stack>
using namespace std;
 struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};


 //将二分查找二叉树的每个节点加上比他大的其他数 https://discuss.leetcode.com/topic/83534/c-solution-beats-100
 /*递归的进行先右子树，因为先遍历到的是最大的数，所以每次更新这个和，子树递归返回后加上它
 */
 int cur_sum;
 void travel(TreeNode* root) {
if (!root) return;
if (root->right) travel(root->right);


root->val = (cur_sum += root->val);
if (root->left) travel(root->left);
 }
 TreeNode* convertBST(TreeNode* root) {
cur_sum = 0;
travel(root);
return root;
 }
 //二叉树层次遍历 https://discuss.leetcode.com/topic/10469/c-solution-using-only-one-queue-use-a-marker-null
 /*树不为空则将头结点和null指针入队列，依次取出头部放入vector中，左右不空则入队列，遇到null的话压入null，将vector压入res
 一定要注意null压入null时必须要判断此时队列是否为空！！！！！！！！！
 */
 vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> res;
if (!root)return res;
vector<int>level;
queue<TreeNode*> q;
q.push(root);
q.push(nullptr);
TreeNode* tmp = nullptr;
while (!q.empty()) {
tmp = q.front();
q.pop();
if (tmp) {
level.push_back(tmp->val);
if (tmp->left)q.push(tmp->left);
if (tmp->right)q.push(tmp->right);
}
else {
res.push_back(level);
level.resize(0);
if (q.size())q.push(nullptr);
}
}
return res;
 }
 //二叉树中序遍历 https://leetcode.com/problems/binary-tree-inorder-traversal/description/
 /*用一个栈维护，每次root不空或者栈不空时，入栈，且让tmp=它的左子树，到空节点了再弹出栈顶，放入vector，让tmp=它的右子树
 */
 vector<int> inorderTraversal(TreeNode* root) {
vector<int> res;
stack<TreeNode*>s;
if (!root)return res;
TreeNode* tmp = root;
while (!s.empty() || tmp) {
if (tmp) {
s.push(tmp);
tmp = tmp->left;
}
else {
tmp = s.top();
s.pop();
res.push_back(tmp->val);
tmp = tmp->right;
}
}
return res;
 }




 //二叉树的每一层的最大平均数 https://discuss.leetcode.com/topic/95206/c-nullptr
 /*是层次遍历的改编，只不过将层次变为累加和计数求平均数而已。还是要注意n队列中出null压入null时判断队列是否为空，否则会造成最后死循环
 */
 //判断两棵树是否一致
 /*递归p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right) 
 */
 bool isSameTree(TreeNode* p, TreeNode* q) {
//if (!p && !q)return true;
//if ((!p&&q) || (!q&&p))return false;
//if (p->val != q->val)return false;
//return (isSameTree(p->left, q->left) && isSameTree(p->right, q->right));
if (p == NULL || q == NULL) return (p == q);
return (p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right));
 }
 //判断是否有一条由根到叶子的节点的值为指定数的路径 https://discuss.leetcode.com/topic/9729/3-lines-of-c-solution
 /*每次向下递归时sum-当前根节点的值，最终的结束条件就是如果满足当前为叶子节点且值为指定的值就返回，否则递归到null，返回false
 */
 bool hasPathSum(TreeNode* root, int sum) {
if (!root)return false;
if (root->val == sum && !root->left && !root->right)return true;
return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
 }
 //从根到叶子节点的和为指定数的所有路径，也可以改编为所有到叶子节点的路径  https://discuss.leetcode.com/topic/18454/12ms-11-lines-c-solution
 /*
 */
 void pathSum(TreeNode* root, int sum, vector<int>& resTmp, vector<vector<int>>& res) {
if (!root)return;
resTmp.push_back(root->val);
if (root->val == sum && !root->left && !root->right)res.push_back(resTmp);
pathSum(root->left, sum - root->val, resTmp, res);
pathSum(root->right, sum - root->val, resTmp, res);
resTmp.pop_back();
 }
 vector<vector<int>> pathSum(TreeNode* root, int sum) {
if (!root)return vector<vector<int>> {};
vector<int> resTmp;
vector<vector<int>> res;
pathSum(root, sum, resTmp, res);
return res;
 }
 // 所有和为给定数的路径 https://leetcode.com/problems/path-sum-iii/discuss/
 /*每次都递归的调用当前的以及左右子树从零开始调用
 */
 int pathSumFromAny(TreeNode* root, int sum, int pre) {
if (!root)return 0;
int cur = pre + root->val;
return (sum == cur) + pathSumFromAny(root->left, sum, cur) + pathSumFromAny(root->right, sum, cur);
 }
 int pathSumFromAny(TreeNode* root, int sum) {
if (!root)return 0;
return pathSumFromAny(root, sum, 0) + pathSumFromAny(root->left, sum) + pathSumFromAny(root->right, sum);
 }
 //合并两颗树 https://leetcode.com/problems/merge-two-binary-trees/description/
 /*其中一颗为空则返回另一颗，两颗不为空则相加，并递归左右子树
 */
 TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
if (!t1 || !t2)return t1 ? t1 : t2;
if (t1&&t2)t1->val += t2->val;
t1->left = mergeTrees(t1->left, t2->left);
t1->right = mergeTrees(t1->right, t2->right);
return t1;
 }




 //输出所有的根节点到子节点的路径 https://leetcode.com/problems/binary-tree-paths/discuss/
 /*只要是叶子节点就push答案
 */
 void binaryTreePaths(TreeNode* root, string s, vector<string>& res) {
if (!root)return;
s += to_string(root->val) + "->";
if (!root->left && !root->right) { s.erase(s.end() - 2, s.end()); res.push_back(s); }
binaryTreePaths(root->left, s, res);
binaryTreePaths(root->right, s, res);
 }
 vector<string> binaryTreePaths(TreeNode* root) {
vector<string> res;
if (!root)return  res;
string tmp;
binaryTreePaths(root, tmp, res);
return res;
 }
// 最大深度 https://leetcode.com/problems/maximum-depth-of-binary-tree/
 int maxDepth(TreeNode* root) {
return root == NULL ? 0 : max(maxDepth(root->left), maxDepth(root->right)) + 1;
 }
 //反转二叉树 https://leetcode.com/problems/invert-binary-tree/discuss/
 /*递归交换左右子树，或者用堆，先压入root，每次弹出，并将他的左右子树压入堆中，如此循环
 */
 TreeNode* invertTree(TreeNode* root) {
//             std::stack<TreeNode*> stk;
//     stk.push(root);


//     while (!stk.empty()) {
//         TreeNode* p = stk.top();
//         stk.pop();
//         if (p) {
//             stk.push(p->left);
//             stk.push(p->right);
//             std::swap(p->left, p->right);
//         }
//     }
//     return root;
if (root) {
TreeNode* tmp = root->left;
root->left = root->right;
root->right = tmp;
if (root->left)invertTree(root->left);
if (root->right)invertTree(root->right);
}
return root;
 }
 //是否为平衡二叉树 https://leetcode.com/problems/balanced-binary-tree/discuss/
 /*递归的查找树节点的深度，判断当前的高度差和左右子树的高度差
 int depth(TreeNode* root) {
 if (!root)return 0;
 return max(depth(root->left), depth(root->right)) + 1;
 }
 bool isBalanced(TreeNode* root) {
 if (!root)return true;
 bool isBal = (abs(depth(root->left) - depth(root->right)) <= 1) ? true : false;
 return isBal&&isBalanced(root->left) && isBalanced(root->right);
 }
 */
 //效率更高的判断是否平衡二叉树
 int isBal(TreeNode*root) {
if (!root)return 0;
int leftH = isBal(root->left);
if (leftH == -1)return -1;
int rightH = isBal(root->right);
if (rightH == -1)return -1;
if (abs(leftH - rightH)>1)return -1;
return max(leftH, rightH) + 1;
 }
 bool isBalanced(TreeNode* root) {
return isBal(root) != -1;
 } 
 //父节点不大于子树的二叉树查找第二小的节点  https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/discuss/
 /*子树存在且和父节点相同，递归往下查找，否则看左右子树返回的大小
 */
 int findSecondMinimumValue(TreeNode* root) {
if (!root)return -1;
int l = (root->left&&root->left->val != root->val) ? root->left->val : findSecondMinimumValue(root->left);
int r = (root->right&&root->right->val != root->val) ? root->right->val : findSecondMinimumValue(root->right);
if (-1 == l || -1 == r)return max(l, r);
return min(l, r);
 }
//左叶子节点的和  https://leetcode.com/problems/sum-of-left-leaves/discuss/
 /*遍历所有的节点，如果它是左子树叶子节点则累加
 */
 void sumOfLeftLeaves(TreeNode* root, int&sum) {
if (!root)return;
if (root->left) {
if (!root->left->left && !root->left->right)sum += root->left->val;
sumOfLeftLeaves(root->left, sum);
}
if (root->right) {
sumOfLeftLeaves(root->right, sum);
}
 }
 int sumOfLeftLeaves(TreeNode* root) {
int sum = 0;
sumOfLeftLeaves(root, sum);
return sum;
 }
 //从右往左看能看到的所有节点  https://leetcode.com/problems/binary-tree-right-side-view/discuss/
 /*层次遍历的最右边，或者递归，先将所有的root的右子树左子树进行递归，根据res的size和层数关系，只有在size小于层数时才可能是res
 */
 vector<int> rightSideView(TreeNode* root) {
vector<int> res;
if (!root)return res;
queue<TreeNode*> q;
q.push(root);
q.push(nullptr);
TreeNode* tmp = nullptr;
while (!q.empty()) {
tmp = q.front();
q.pop();
if (tmp) {
if (q.front() == nullptr)res.push_back(tmp->val);
if (tmp->left)q.push(tmp->left);
if (tmp->right)q.push(tmp->right);
}
else {
if (q.size())q.push(nullptr);
}
}
return res;
 }
 void rightSideViewRec(TreeNode* root, int lv, vector<int> &res) {
if (!root)   return;
if (lv >= res.size()) res.push_back(root->val);
rightSideViewRec(root->right, lv + 1, res);
rightSideViewRec(root->left, lv + 1, res);
 }
 vector<int> rightSideViewRec(TreeNode* root) {
vector<int> res;
rightSideViewRec(root, 0, res);
return res;
 }
 //将二叉树从根节点到叶子节点看做一个数，求所有数之和（叶子结点的和）https://leetcode.com/problems/sum-root-to-leaf-numbers/description/
 void sumNumbers(TreeNode* root, int cursum, int &sum) {
if (root && !root->left && !root->right) sum += cursum + root->val;
if (root->left)sumNumbers(root->left, (cursum + root->val) * 10, sum);
if (root->right)sumNumbers(root->right, (cursum + root->val) * 10, sum);
 }
 int sumNumbers(TreeNode* root) {
int sum = 0, cursum = 0;
if (root) {
sumNumbers(root, cursum, sum);
}
return sum;
 }
 //将树用括号进行表示层之间的关系


 string tree2str(TreeNode* t) {
if (t == NULL) return "";
string s = to_string(t->val);
if (t->left) s += '(' + tree2str(t->left) + ')';
else if (t->right) s += "()";
if (t->right) s += '(' + tree2str(t->right) + ')';
return s;
 }
 // 判断t是否为s的一颗子树 https://discuss.leetcode.com/topic/88508/java-solution-tree-traversal/5
 /* 先判断当前是否是相同，不相同则让它的左右子树和t进行比较，注意&& 和||
 */
 bool isSame(TreeNode* s, TreeNode* t) {
if (!s && !t)return true;
if (!s || !t)return false;
if (s->val != t->val)return false;
return isSame(s->left, t->left) && isSame(s->right, t->right);
 }
 bool isSubtree(TreeNode* s, TreeNode* t) {
if (isSame(s, t))return true;
return (s->left == nullptr ? false : isSubtree(s->left, t))
|| (s->right == nullptr ? false : isSubtree(s->right, t));
 }
 //重复最多的子树和，每个子树和定义为根节点与所有子节点的和 https://discuss.leetcode.com/topic/77763/short-clean-c-o-n-solution/9
 /*用map去记录所有和的计数，递归的计算子树和，使用临时变量sum存储子树和以及向上返回和
 */
 int sumTree(TreeNode* root, map<int, int>&hm, vector<int>&res, int& maxCnt) {
if (!root)return 0;
int sum = root->val + sumTree(root->left, hm, res, maxCnt) + sumTree(root->right, hm, res, maxCnt);
hm[sum]++;
if (maxCnt<hm[sum]) { res.clear(); maxCnt = hm[sum]; res.push_back(sum); }
else if (maxCnt == hm[sum]) { res.push_back(sum); }
return sum;
 }
 vector<int> findFrequentTreeSum(TreeNode* root) {
map<int, int>hm;
vector<int>res;
int maxCnt = INT_MIN;
sumTree(root, hm, res, maxCnt);
return res;
 }
 //子树中是否有重复的子树 https://leetcode.com/problems/find-duplicate-subtrees/discuss/
 /*对每个子节点获取子树的字符串括号表示形式，在将他们作为map的键值，并将节点压入，最后遍历map对应的vector的size大小，大于2说明有重复
 */
 string getSubtrees(TreeNode* root, map<string, vector<TreeNode*> >& hm) {
if (!root)return "";
string s = "(" + getSubtrees(root->left, hm) + to_string(root->val) + getSubtrees(root->right, hm) + ")";
hm[s].push_back(root);
return s;
 }
 vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) {
vector<TreeNode*> res;
map<string, vector<TreeNode*> > hm;
getSubtrees(root, hm);
for (auto i = hm.begin(); i != hm.end(); ++i) {
if (i->second.size() >= 2)res.push_back(i->second[0]);
}
return res;
 }
 //返回最小的二叉树深度  https://leetcode.com/problems/minimum-depth-of-binary-tree/discuss/
 /*任何一边为空就返回另一边+1 两边都有就选择小的+1
 */
 int minDepth(TreeNode* root) {
if (!root)return 0;
if (!root->right)return minDepth(root->left) + 1;
if (!root->left)return minDepth(root->right) + 1;
return min(minDepth(root->left), minDepth(root->right)) + 1;
 }
 //返回树中经过某个节点的最长的路径   https://leetcode.com/problems/diameter-of-binary-tree/discuss/
 /*类似于递归的求一个节点的左右子树的最大高度，最长路径肯定经过这两条路径 每次比对
 */
 int diameterOfBinaryTree(TreeNode* root, int&maxDepth) {
if (!root)return 0;
int leftD = diameterOfBinaryTree(root->left, maxDepth);
int rightD = diameterOfBinaryTree(root->right, maxDepth);
maxDepth = max(maxDepth, leftD + rightD);
return max(leftD, rightD) + 1;
 }
 int diameterOfBinaryTree(TreeNode* root) {
int maxDepth = 0;
diameterOfBinaryTree(root, maxDepth);
return maxDepth;
 }
 //查询二叉树中是否有两个数和为指定数k https://leetcode.com/problems/two-sum-iv-input-is-a-bst/discuss/
 /*利用map或set，递归的判断k-val是否存在,将root的val压入,或者可以使用一个查询函数，
 */
 bool findTarget(TreeNode* root, int& k, map<int, int>&mp) {
if (!root)return false;
if (mp[k - root->val])return true;
mp[root->val]++;
return findTarget(root->left, k, mp) || findTarget(root->right, k, mp);
 }
 bool findTarget(TreeNode* root, int k) {
if (!root)return false;
map<int, int>mp;
return findTarget(root, k, mp);
 }
 //删除二叉树中等于某个值的节点 https://leetcode.com/problems/delete-node-in-a-bst/discuss/
 /*如果右子树为空那么删除root然后直接返回它的左子树就可以，否则用右子树最左边的和它交换，但注意千万不要在这个时候就删除交换后的子树，因为它虽然是右子树的
 最左节点，但它本身可能还有右子树，因此仅交换，最终它会作为叶子节点被删除
 */
 TreeNode* deleteNode(TreeNode* root, int key) {
if (!root)return nullptr;
if (root->val == key) {
if (!root->right) {
TreeNode* left = root->left;
delete root;
return left;
}
else {
TreeNode* right = root->right;
while (right->left) {
right = right->left;
}
swap(right->val, root->val);
// delete right;
//return root;
}
}
root->left = deleteNode(root->left, key);
root->right = deleteNode(root->right, key);
return root;
 } 
 //判断是否是一个镜像树 https://leetcode.com/problems/symmetric-tree/discuss/ 
 /*为空或者左右子树符合：两个为空（注意这个精妙的判断语句）或者它们的左右子树进行判断
 */
 bool isSymmetric(TreeNode* root1, TreeNode* root2) {
if (!root1 || !root2)return root1 == root2;
if (root1->val != root2->val)return false;
return isSymmetric(root1->left, root2->right) && isSymmetric(root2->left, root1->right);
 }
 bool isSymmetric(TreeNode* root) {


return !root || isSymmetric(root->left, root->right);
 }
 //二叉查找树中第k小的数字  https://leetcode.com/problems/kth-smallest-element-in-a-bst/discuss/
 /*中序遍历查找，或者递归查找，看左子树有多少个数字，如果刚好k-1个时就是要找的，小于的话继续递归的查找左子树上的节点，大于的话要在右子树上
 递归的查找k-n-1大的节点
 */
 int kthSmallest(TreeNode* root, int k) {
vector<int> res;
int index = 0;
stack<TreeNode*> s;
TreeNode* tmp = root, *top = nullptr;
while (!s.empty() || tmp) {
if (tmp) {
s.push(tmp);
tmp = tmp->left;
}
else {
top = s.top();
s.pop();
if (++index == k)return top->val;
tmp = top->right;
}
}
return 0;
 }
 int countChild(TreeNode* root) {
if (!root)return 0;
return countChild(root->left) + countChild(root->right) + 1;
 }
 int kthSmallestRec(TreeNode* root, int k) {
int leftChildCount = countChild(root->left);
if (k - 1<leftChildCount)return kthSmallest(root->left, k);
if (k - 1>leftChildCount)return kthSmallest(root->right, k - 1 - leftChildCount);
return root->val;
 }
 //普通二叉树给定两个节点的最低公共祖先  https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/discuss/
 /*如果根节点=所找的或者为空，返回根节点（边界条件，递归到叶子）
 递归查找左右子树，如果左子树查找为空 ，那么就返回右子树，不为空则看右子树，右子树如果为空，那就返回左子树，不然就返回根节点，说明左右子树找到了  
 */
 TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if (!root || root == p || root == q)return root;
TreeNode* left = lowestCommonAncestor(root->left, p, q);
TreeNode* right = lowestCommonAncestor(root->right, p, q);
return !left ? right : (!right ? left : root);
 }
 //查找二叉树，查找两个节点的最低公共节点 https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/discuss/
 /*如果根节点在他们之间 返回根节点，比他们都大，往左子树查，比他们都小，往右查
 */
 TreeNode* lowestCommonAncestorBS(TreeNode* root, TreeNode* p, TreeNode* q) {
// if(q->val>=root->val>=p->val||q->val>=root->val>=p->val)return root;
if (root->val>p->val&&root->val>q->val)return lowestCommonAncestorBS(root->left, p, q);
if (root->val<p->val&&root->val<q->val)return lowestCommonAncestorBS(root->right, p, q);
return root;
 }
 //检查是否为二分查找树 
 /*对树进行中序遍历，应该为一个有序的数组，这个时候用pre记录每次弹出的root，以便作为下次弹出时比较
 */
 bool isValidBST(TreeNode* root) {
if (!root)return true;
stack<TreeNode* >s;
TreeNode* pre = nullptr;
while (root || !s.empty()) {
if (root) {
s.push(root);
root = root->left;
}else {
root = s.top();
s.pop();
if (pre&&root->val <= pre->val)return false;
pre = root;
root = root->right;
}
}
return true;
 }
 //给定一个升序数组，制造一个平衡二叉排序树 https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/discuss/
 /*每次取中间的那个数，生成一个节点，通过左右部分递归的生成左右子树，注意加上null节点的情况
 */
 TreeNode* sortedArrayToBST(vector<int>& nums, int left, int right) {
if (left == right)return new TreeNode(nums[left]);
if (left>right)return nullptr;
int mid = (left + right) / 2;
TreeNode * root = new TreeNode(nums[mid]);
root->left = sortedArrayToBST(nums, left, mid - 1);
root->right = sortedArrayToBST(nums, mid + 1, right);
return root;
 }
 TreeNode* sortedArrayToBST(vector<int>& nums) {
if (!nums.size())return nullptr;
return sortedArrayToBST(nums, 0, nums.size() - 1);
 }
 //返回所有节点的左右子树和之差的绝对值之和 https://leetcode.com/problems/binary-tree-tilt/discuss/
 /*   5      递归的求子树和，累加子树差的绝对值
1   4
   1 5 2  5
 */
int findTilt(TreeNode* root, int& sum) {
if (!root)return 0;
int left = findTilt(root->left, sum);
int right = findTilt(root->right, sum);
sum += abs(left - right);
return left + right + root->val;
}
int findTilt(TreeNode* root) {
int sum = 0;
findTilt(root, sum);
return sum;
}
//将一棵树输入到一个数组中，数组长度为2^d-1，宽度为d https://leetcode.com/problems/print-binary-tree/discuss/
/*   2      ["","2"," "] 每一层的root都位于一个范围的中心
   3   4    ["3","","4"]
*/
int getDepth(TreeNode* root) {
if (!root)return 0;
return max(getDepth(root->left), getDepth(root->right)) + 1;
}
void getPrintTree(TreeNode* root, int level, int left, int right, vector<vector<string>>&res) {
if (!root)return;
int mid = (left + right) / 2;
res[level][mid] = to_string(root->val);
getPrintTree(root->left, level + 1, left, mid - 1, res);
getPrintTree(root->right, level + 1, mid + 1, right, res);
}
vector<vector<string>> printTree(TreeNode* root) {
int d = getDepth(root);
int w = pow(2, d) - 1; cout << w;
vector<vector<string>> res(d, vector<string>(w, ""));
getPrintTree(root, 0, 0, w, res);
return res;
}
//一颗完全二叉树的节点个数 https://leetcode.com/problems/count-complete-tree-nodes/discuss/
/*如果最左边和最右边的长度相等那就是2^n-1个，否则递归遍历
*/
int countNodes(TreeNode* root) {
if (!root)return 0;
int hl = 0, hr = 0;
TreeNode *l = root, *r = root;
while (l) { hl++; l = l->left; }
while (r) { hr++; r = r->right; }
if (hl == hr) return pow(2, hl) - 1;
return countNodes(root->left) + countNodes(root->right) + 1;
}
//第n层增加一层   https://leetcode.com/problems/add-one-row-to-tree/discuss/
/*当d-到1或者2的时候处理
*/
TreeNode* addOneRow(TreeNode* root, int v, int d) {
if (!root || d<1)return root;
if (d == 1) {
TreeNode* newhead = new TreeNode(v);
newhead->left = root;
return newhead;
}
if (d == 2) {
if (root) {
TreeNode*l = root->left;
TreeNode*r = root->right;
root->left = new TreeNode(v);
root->right = new TreeNode(v);
root->left->left = l;
root->right->right = r;
return root;
}
}
addOneRow(root->left, v, d - 1);
addOneRow(root->right, v, d - 1);
return root;
}
//模拟查找二叉树的next返回最小值，hasnext返回是否还有最小值  https://leetcode.com/problems/binary-search-tree-iterator/discuss/
/*模拟二叉树的中序遍历  
*/
stack<TreeNode *> bstS;
void   putAllNode(TreeNode *root) {
while (root) {
bstS.push(root);
root = root->left;
}
}
void BSTIterator(TreeNode *root) {
putAllNode(root);
}
/** @return whether we have a next smallest number */
bool hasNext() {
return !bstS.empty();
}
/** @return the next smallest number */
int next() {
TreeNode* top = bstS.top();
bstS.pop();
putAllNode(top->right);
return top->val;
}




 TreeNode *getATree(){
TreeNode *root = new TreeNode(10);
TreeNode *l1t1 = new TreeNode(5);
TreeNode *l1t2 = new TreeNode(-3);
TreeNode *l2t1 = new TreeNode(3);
TreeNode *l2t2 = new TreeNode(2);
TreeNode *l2t3 = new TreeNode(11);
TreeNode *l3t1 = new TreeNode(3);
TreeNode *l3t2 = new TreeNode(-2);
TreeNode *l3t3 = new TreeNode(1);
root->left = l1t1;
root->right = l1t2;
l1t1->left = l2t1;
l1t1->right = l2t2;
l1t2->right = l2t3;
l2t1->left = l3t1;
l2t1->right = l3t2;
l2t2->right = l3t3;
return root;
 }
 struct bs
 {
char d[20];
int a : 1;
int b : 4;
int c:3;
int e;
//long long b;
 }data;
 struct foo2 {
char    a : 2;
char    b : 3;
char    c : 1;
char d;
 };
 struct foo3 {
char    a : 2;
char    b : 3;
char    c : 7;
 };


int main()
{
TreeNode *root = new TreeNode(1);
int a[2][3];
cout << a << "===" << &a << "\na + 1 " << a + 1 << "\n&a + 1 " << &a + 1 << "\na[0] + 1 " << a[0] + 1 << "\n&a[0] + 1" << &a[0] + 1;
system("pause");
    return 0;
}