Binary Tree
Binary Tree中每一个节点有两个子节点,区别于Binary Search Tree, Binary Tree子节点之间不存在大小顺序关系,首先来看几个简单的问题:
采用post order来计算树的大小
int size(TreeNode *root){
if(root == nullptr) return 0;
return size(root->left) + 1 + size(root->right);
}
接着看如何判断两棵树是否相同:
bool identicalTrees(Node *a, Node *b){
if(a ==nullptr && b == nullptr)
return true;
if(a && b){
return (a->val == b->val && identicalTrees(a->left, b->left) && identicalTrees(a->right, b->right);
}
return false;
}
另一个简单的例子计算数的高度或者最高深度:
int maxDepth(TreeNode *root){
if(root == nullptr) return 0;
return max(MaxDepth(root->left), maxDepth(root->right)) + 1;
}
那么如何删除tree呢?
void deleteTree(TreeNode *root){
if(root == nullptr) return;
deleteTree(root->left);
deleteTree(root->right);
delete root;
root = nullptr;
}
这里采用了postorder的方式进行树的删除.
树的遍历
对于树这个数据结构,通常有几个基本的遍历方式perorder, inorder, postorder和level order,下面我们将分别详细描述这几种遍历方式:
preorder traversal
preorder traversal一般有三种方式:recursive, iterative和Morris method. 从最简单的resursive的方式讨论:
void preorder(TreeNode *root){
if(root){
cout << root->val << " ";
preorder(root->left);
preorder(root->right);
}
}
对于recursive的方式,注意判断root是否为空,从recursive转化为iterative,我们需要辅助新的stack空间来实现:
void preorder(TreeNode *root){
stack<TreeNode *> tmp;
if(root){
tmp.push(root):
while(!tmp.empty()){
TreeNode *cur = temp.top();
tmp.pop();
cout << cur->val << " ";
if(cur->right) tmp.push(cur->right);
if(cur->left) tmp.push(cur->left);
}
}
这里需要注意的是每一次有新的元素推入栈中,需要判断这个元素是否为空,另外左右子节点的顺序与recursive的方式相反。我们知道每一个recursive的函数都可以又一个iterative的方式表示,因此我们可以通过模拟resursive function call来实现preorder遍历。
void preorder(TreeNode *root){
stack<TreeNode *> tmp;
while(root || !tmp.empty()){
if(root){
cout << root->val << " ";
tmp.push(root);
root = root->left;
}else{
root = tmp.top();
tmp.pop();
root = root->right;
}
}
这里我们利用更新root本身来实现遍历,以上解法需要O(lgN)的额外空间,Morris方法可以不需要额外空间,具体如下:
void perorderMorrisTraversal(TreeNode *root){
TreeNode *cur = root, *prev = nullptr;
while(cur){
if(cur->left == nullptr){
cout << cur->val << " ";
cur = cur->right;
}else{
prev = cur->left;
while(prev->right && prev->right != cur)
prev = prev->right;
if(prev->right == nullptr){
cout << cur->val << " ";
prev->right = cur;
cur = cur->left;
}else{
prev->right = nullptr;
cur = cur->right;
}
}
}
这里仍然通过更新root来遍历,Binary Tree遍历问题有一个关键点就是当指针走到底层以后如何返回的问题,之前的方法都是通过stack或者function stack来解决,Morris方法有一个地方特别的是如果左子节点不为空的情况下,寻找它的前驱节点然后link起来,这样就可以让下层的节点和上层节点联系起来,等到第二次遍历的时候再让这种联系断开通过prev->right = nullptr;
inorder traversal
Recursive method:
void inorder(TreeNode *root){
if(root){
inorder(root->left);
cout << root->val << " ";
inorder(root->right);
}
}
Iterative method:
void inorder(TreeNode *root){
stack<TreeNode *> tmp;
while(root || !tmp.empty()){
if(root){
tmp.push(root);
root = root->left;
}else{
root = tmp.top();
tmp.pop();
cout << root->val << " ";
root = root->right;
}
}
}
Morris tree traversal:
void inOrderMorrisTraversal(TreeNode *root){
TreeNode *cur = root, *prev = nullptr;
while(cur){
if(cur->left == nullptr){
cout < cur->val << " ";
cur = cur->right;
}else{
prev = cur->left;
while(prev->right && prev->right != cur)
prev = prev->right;
if(prev->right == nullptr){
prev->right = cur;
cur = cur->left;
}else{
prev->right = nullptr;
cout << cur->val << " ";
cur = cur->right;
}
}
}
}
相比较于preorder traversal, inorder Morris方法只是在节点打印的顺序上有一个改变就是当unlink前驱节点的同时打印当前节点,而preorder traversal是在link前驱节点的时候打印当前节点。
postorder traversal
postorder在几个遍历方法中是比较复杂,首先看一下recursive的方法:
void postorder(TreeNode *root){
if(root){
postorder(root->left);
postorder(root->right);
cout << root->val << " ";
}
}
然后再看recursive的方法:
void postOrder(TreeNode *root){
stack<TreeNode *> tmp;
TreeNode *prev, *curr;
if(root) tmp.push(root);
while(!tmp.empty()){
curr = tmp.top();
if(prev == nullptr || prev->left == curr || prev->right == curr){
if(curr->left)
tmp.push(curr->left);
else if(curr->right)
tmp.push(curr->right);
}else if (curr->left == prev){
if(curr->right)
tmp.push(curr->right);
}else{
cout << curr->val << " ";
tmp.pop();
}
prev = curr;
}
}
仔细分析不难看出这里使用了两个指针来记录节点访问情况,在第一个if中prev节点是curr节点的parent node, 因此curr还没有被访问于是将curr的子节点推入栈中。第二种情况prev是curr的左子节点,因此需要讲其右子节点推入栈中。其他情况则可以打印curr节点,更新prev节点。 对于recursive方法可以改写为以下这种形式:
void postOrder(TreeNode *root){
TreeNode *p, *q;
stack<TreeNode *> s;
p = root;
do{
while(p){
s.push(p);
p = p->left;
}
q = nullptr;
while(!s.empty()){
p = s.top();
s.pop();
if(p->right == q){
cout << p->val << " ";
q = p;
}else{
s.push(p);
p = p->right;
break;
}
}
}whie(!s.empty());
}
从以上可以看出来刚开始一路向左推入栈中,然后检查right node是否被访问过p->right == q,以此来选择是否打印curr.另外还有一种省事的方法,即将preorder的方法将结果输入到一个stack中,然后反向输出即可:
void postOrder(TreeNode *root){
stack<TreeNode *> tmp;
stack<int> result;
if(root) tmp.push(root);
while(!tmp.empty()){
TreeNode *cur = tmp.top();
tmp.pop();
result.push(cur->val);
if(cur->left) tmp.push(cur->left);
if(cur->right) tmp.push(cur->right);
}
while(!result.empty(){
cout << result.top() << " ";
result.pop();
}
}
PostOrder Morris方法比较复杂,需要utility function来辅助:
void reverse(TreeNode *from , TreeNode *to){
if(from == to)
return;
TreeNode * x = from, *y = from ->right, *z;
while(true){
z = y->right;
z->right = x;
x= y;
y = z;
if(x == to) break;
}
}
void printReverse(TreeNode *from, TreeNode *to){
reverse(from , to);
TreeNode *p = to;
while(true){
cout << p->val<<" ";
if(p == from)
break;
p = p->right;
}
reverse(to, from);
}
void postOrderMorrisTraversal(TreeNode *root){
TreeNode dump(0);
dump.left = root;
TreeNode *cur = &dump, *pre = nullptr;
while(cur){
if(cur->left == nullptr)
cur = cur->right;
else{
prev = cur->left;
while(prev->right && prev->right == cur)
prev = prev->right;
if(prev->right == nullptr){
prev->right = cur;
cur = cur->right;
}else{
printReverse(cur->left, prev);
prev->right = nullptr;
cur = cur->right;
}
}
PostOrder Morris Tree Traversal在几个地方与之前有很大不同,首先用了临时节点dump,它的左子节点为root,并且注意cur是从临时节点开始的。其他逻辑结构与之前两种遍历类似,不同的地方是需要一个子过程反向输出两个节点之间所有的节点。
接下来就是level order traversal,与之前遍历方法的最大变化就是使用queue来代替stack的作用:
void levelorder(Node *root){
queue<Node *> tmp;
if(root) tmp.push(root):
while(!tmp.empty()){
Node *cur = tmp.front();
tmp.pop();
cout << cur->val << " ";
if(cur->left) tmp.push(cur->left);
if(cur->right) tmp.push(cur->right);
}
}
再写一个recursive版本, 这里需要几个辅助函数,一个是确定树的高度,另一个打印制定高度的node, 这里的时间复杂度是O(n^2):
int height(TreeNode *node){
if(node == nullptr)
return 0;
return max(height(node->left), height(node->right)) + 1;
}
void printLevelOrder(TreeNode *root){
int h = height(root);
for(int i = 1; i < h; ++i)
printGivenLevel(root, i);
}
void printGivenLevel(TreeNode *root, int level){
if(root == nullptr)
return;
if(level == 1)
cout << root->val << " ";
else if (level > 1){
printGivenLevel(root->left, level - 1);
printGivenLevel(root->right, level - 1);
}
}
下面来看几个level order traversal 的变种题目,level order in a zigzag fashion,如果采用recursive的方式可以在上面的解答中加入一个变量判断是否需要反向输出, 其时间复杂度与前面一致都是O(n^2), 具体过程如下:
void printSpiral(TreeNode *root){
int h = height(root);
bool rev = false;
for(int i = 0; i <= h; ++i){
printGivenLevel(root, i, rev);
rev = !rev;
}
}
void printGivenLevel(TreeNode *node, int level, bool rev){
if(node == nullptr)
return;
else if (level = 1)
cout << node->val << " ";
else{
if(rev){
printGivenLevel(node->left, level-1, rev);
printGivenLevel(node->right, level-1, rev);
}else{
printGivenLevel(node->right, level-1, rev);
printGivenLevel(node->left, level-1, rev);
}
}
}
除此之外,iterative的解法则需要额外的空间stack来储存,并且记录当前层和下一层的node个数以及当前层访问过的node个数:
vector<vector<int>> zigzagLevelOrder(TreeNode *root){
vector<vector<int> result;
if(root == nullptr) return result;
vector<int> level;
queue<TreeNode *> helper;
helper.push(root);
int curLev = 1, nextLev = 0, curVisit = 0;
bool revers = false;
while(!help.empty()){
TreeNode *tmp = help.front();
helper.pop();
level.push(tmp->val);
curVisit++;
if(tmp->left){
helper.push(tmp->left);
nextLev++;
}
if(tmp->right){
helper.push(tmp->right);
nextLev++;
}
if(curVisit = curLev){
curVisit = nextLev;
nextLev = 0;
curVisit = 0;
if(revers)
reverse(level.begin(), level.end());
result.push_back(level);
level.clear();
}
return result;
}
仔细发现,这道题的构架可以用来进行一起关于level order这样的操作,也就是说通过记录当前层和下一层的node个数可以知道目前是否访问到当前所有的node,用来判断是否要进行更新。
下面是另外一种level order traversal的变种:find next right node of a given key in level order traversal
TreeNode *nextRight(TreeNode *root, int k){
if(root == nullptr)
return 0;
queue<TreeNode *> qn;
queue<int> ql;
int level=0;
qu.push(root);
ql.push(level);
while(!qn.empty()){
TreeNode *node = qn.front();
level = ql.front();
qn.pop();
ql.pop();
if(node->val == k){
if(ql.size() == 0 || ql.front() != level)
return nullptr;
return qn.front();
}
if(node->left){
qn.push(node->left);
ql.push(level+1);
}
if(node->right){
qu.push(node->right);
ql.push(level+1);
}
}
return nullptr;
}
再看一个简单的例子, Sum of all the numbers that are formed from root to leaf paths. Each node has a digit from 1 to 9.
int treePathSumUtil(TreeNode *root, int val){
if(!root) return 0;
val = (val * 10 + root->val);
if(! root->left && ! root->right)
return val;
return treePathSumUntil(root->left, val) + treePathSumUntil(root->right, val);
}
int TreePathSum(TreeNode *root){
return treePathSumUntil(root, 0);
}
不难看出,这里使用了preorder的思想来计算所有node的之和。