二叉树操作集锦
开学了，找工作也正式拉开了序幕，每天光自己看书，也很没劲，和大家一起分享分享，交流一下笔试面试过程中的各种算法题目，如有问题，欢迎指正，希望大家一起进步。。。
下面是对数据结构二叉树的一些基本操作，可能在面试中都会涉及到。我们都知道二叉树的定义本身就是一种递归定义，所以对树的大部分操作都可以通过递归的方式进行，但递归不是万能的，因为递归的本身是一件很浪费内存资源的操作，所以在选择算法的时候要权衡各种因素，选取最合理的算法。下图Fig 1 是下面代码中举例会用到的图：
Fig 1
在本文中，所讨论的二叉树采取以下的定义方式：
templatestruct BiNode{ Type data; BiNode *left; BiNode *right;};
下面就是各种对二叉树的操作，也行大家在各种面试书中看过了，这些题目在面试中可能会经常出现，所以要秒杀它们。。。
1.二叉树的创建
下面的创建是采用递归的方式进行创建，节点的内容为字符。节点的创建方式是先序的方式，先创建根节点，然后是左子树，最后是右子树。
/**
*Create Binary Tree
*/
BiNode<char> * CreateBiTree()
{
BiNode<char> *root;
char data;
cin>>data;
if(data == '$')
return NULL;
root = new BiNode<char>;
root->data = data;
root->left = CreateBiTree();
root->right = CreateBiTree();
return root;
}
2.二叉树的各种遍历
下面的算法是二叉树的各种遍历，包括先序，中序，层次遍历，其中有非递归和递归的算法，关于后序遍历这里没有列举，因为后序的非递归相对比较复杂，每个节点要进出栈两次，在面试的过程中一般面试官不是变态的话，不会考后序的非递归算法的。
2.1 先序遍历
下面是先序遍历的递归算法：
/**
* recursively pre-order traverse the binary tree
* 先序遍历递归算法
*/
template <typename Type>
void PreOrder( BiNode<Type> *root )
{
if(root == NULL)
return;
cout<<root->data<<endl;
PreOrder(root->left);
PreOrder(root->right);
}
下面是先序遍历的非递归算法，非递归的思想就是通过栈来模拟递归的过程，非递归的先序遍历就是在每访问一个节点后，讲该节点的右孩子压入栈，然后再将左孩子压栈。
/**
* non-recursively pre-order traverse the binary tree
* 先序遍历非递归算法
*/
template <typename Type>
void PreOrder_NonRecursive( BiNode<Type> *root )
{
if(root == NULL)
return;
stack<BiNode<Type> *> nodeStack;
nodeStack.push(root);
while(!nodeStack.empty())
{
BiNode<Type> *node = nodeStack.top();
nodeStack.pop();
cout<<node->data<<endl;
if(node->right)
nodeStack.push(node->right);
if(node->left)
nodeStack.push(node->left);
}
}
2.2 中序遍历
下面是中序遍历的递归算法：
/**
* recursively in-order traverse the binary tree
* 中序遍历递归算法
*/
template <typename Type>
void InOrder( BiNode<Type> *root )
{
if(root == NULL)
return;
InOrder(root->left);
cout<<root->data<<endl;
InOrder(root->right);
}
下面是中序遍历的非递归算法，中序遍历非递归的思想就是将节点的沿着左子树的方向一直入栈，直到左子树为空，然后弹出栈里的元素进行访问，如果该节点存在右子树，则重复执行上述操作。
/**
* non-recursively in-order traverse the binary tree
* 中序遍历非递归算法
*/
template <typename Type>
void InOrder_NonRecursive( BiNode<Type> *root )
{
if (root == NULL)
return;
stack<BiNode<Type> *> nodeStack;
BiNode<Type> *node = root;
while (node != NULL || !nodeStack.empty())
{
if (node != NULL)
{
nodeStack.push(node);
node = node->left;
}
else
{
node = nodeStack.top();
nodeStack.pop();
cout<<node->data<<endl;
node = node->right;
}
}
}
2.3 层次遍历
二叉树的层次遍历就是按照节点的深度从上往下，从左往右依次访问树中的每一个节点。
下面这种方法是通过队列来完成的，首先将根节点入队列，然后重复进行如下操作：读取队头节点元素，并将节点的左右孩子写入队列，直到队列为空。
/**
* level order traverse the binary tree
* method 1
*/
template <typename Type>
void LevelOrder_1( BiNode<Type> *root )
{
if (root == NULL)
return;
queue<BiNode<Type> *> nodeQueue;
nodeQueue.push(root);
while (!nodeQueue.empty())
{
BiNode<Type> *node = nodeQueue.front();
nodeQueue.pop();
cout<<node->data<<" ";
if(node->left)
nodeQueue.push(node->left);
if(node->right)
nodeQueue.push(node->right);
}
}
上面的算法不能清晰的按层次单独的打印二叉树的每层数据，下面有二种方法可以代替这种方法。
/**
* level order traverse the binary tree
* method 2
*/
template <typename Type>
void LevelOrder_2( BiNode<Type> *root )
{
if (root == NULL)
return;
//GetBinTreeHeight()函数用于获取二叉树的高度，后面会有介绍
for (int i = 1; i <= GetBinTreeHeight(root); ++i)
{
PrintKthLevelOrder(root, i);
cout<<endl;
}
}
/**
* print the k(th) level node of binary tree
* 打印二叉树的第K层的节点
*
* @param k the level, its value must be 1 <= k <= tree height
*/
template <typename Type>
void PrintKthLevelOrder( BiNode<Type> *root, int k)
{
if (root == NULL)
return;
if(k == 1)
{
cout<<root->data<<" ";
return;
}
PrintKthLevelOrder(root->left, k - 1);
PrintKthLevelOrder(root->right, k - 1);
}
上面的代码完成了独立的遍历每一层的节点。但我们会发现，遍历每一层节点都会从根节点往下开始，这样会存在大量的重复操作，一般的面试官是不会满意这种算法的。下面就是通过STL vector来存储遍历的节点，过程和通过队列访问类型，但用了两个index来标识每一层。具体可以参考编程之美3.10节。下面是代码：
/**
* level order traverse the binary tree
* method 3
*/
template <typename Type>
void LevelOrder_3( BiNode<Type> *root )
{
if (root == NULL)
return;
vector<BiNode<Type> *> nodeVec;
nodeVec.push_back(root);
int cur, last;
cur = 0, last = 1;
while(cur < nodeVec.size())
{
cout<<nodeVec[cur]->data<<" ";
if(nodeVec[cur]->left != NULL)
nodeVec.push_back(nodeVec[cur]->left);
if(nodeVec[cur]->right != NULL)
nodeVec.push_back(nodeVec[cur]->right);
++cur;
if (cur == last)
{
cur = last;
last = nodeVec.size();
cout<<endl;
}
}
}
3.二叉树的高度
二叉树的高度可以通过后序遍历的思想，递归的统计节点的左子树和右子树的高度，然后取左右子树高度的最高值，然后加1，就是该层节点的高度。代码如下：
/**
* calculate the height of binary tree
*/
template <typename Type>
int GetBinTreeHeight( BiNode<Type> *root)
{
if (root == NULL)
return 0;
int lHeight = GetBinTreeHeight(root->left);
int rHeight = GetBinTreeHeight(root->right);
if(lHeight < rHeight)
return rHeight + 1;
return lHeight + 1;
}
4.二叉树第K层节点的个数
也是通过后序遍历的思想，分别求节点左右子树在第K层的节点个数，然后求和。这里对传入的k，随着递归深度的加深，逐渐减1，直到k为1。
/**
* calculate the node counts in k(th) level
*
* @param k the level, its value must be 1 <= k <= tree height
*/
template <typename Type>
int GetNodeCountsKthLevel( BiNode<Type> *root, int k)
{
//检测k否超过二叉树的高度
if (root == NULL || k < 1 || k > GetBinTreeHeight(root))
return 0;
if(k == 1)
return 1;
return GetNodeCountsKthLevel(root->left, k - 1) \
+ GetNodeCountsKthLevel(root->right, k - 1);
}
这里为了增强代码的鲁棒性，加入了对传入参数k的合法性的检验k本身的取值范围应该是：1 =< k <= tree height
5.叶子节点的个数
和前面的道理一样，在二叉树的操作中，递归才是王道。。。
/**
* calculate the leaf node counts
*/
template <typename Type>
int GetLeavesCounts( BiNode<Type> *root)
{
if (root == NULL)
return 0;
if(root->left == NULL && root->right == NULL)
return 1;
return GetLeavesCounts(root->left) + GetLeavesCounts(root->right);
}
6.二叉树节点的个数
template <typename Type>
int GetNodeCounts( BiNode<Type> *root)
{
if(root == NULL)
return 0;
return GetNodeCounts(root->left) + GetNodeCounts(root->right) + 1;
}
也可以通过传入参数，通过先序遍历的思想，每访问一个节点就将计数器加1，直到遍历完所有节点为止。
7.二叉排序树转换成排序的双向链表
这个已近在前面的博客中写过，详见： http://blog.csdn.net/anonymalias/article/details/9204825
8.二叉树的子结构
二叉树的子结构的定义是：一个二叉树为另一个二叉树的子集，如下图所示：
Fig 2 B为A的一个子结构
那么对于这个题目的解题思路是：在A中查找与B根节点相同的节点X，找到后将该节点X的左右子树与B的左右子树依次比较，如果B的所有节点都在X的左右子树中，那么就认为B是A的子结构，如果B的所有节点不都在X的左右子树中，那么在A中继续查找另外一个X节点，直到结束。下面是代码：
/**
* judge the binary tree 'rootB' is a substructure of 'rootA'or not
*/
template <typename Type>
bool IsSubStruct(BiNode<Type> *rootA, BiNode<Type> *rootB)
{
if (rootA == NULL || rootB == NULL)
return false;
bool result = false;
if (rootA->data == rootB->data)
result = ISSameStruct(rootA, rootB);
if(!result)
result = IsSubStruct(rootA->left, rootB);
if(!result)
result = IsSubStruct(rootA->right, rootB);
return result;
}
//用于判断二叉树B是否是A开始的一部分
template<typename Type>
bool ISSameStruct(BiNode<Type> *rootA, BiNode<Type> *rootB)
{
if(rootB == NULL)
return true;
if(rootA == NULL)
return false;
if(rootA->data != rootB->data)
return false;
return ISSameStruct(rootA->left, rootB->left) && ISSameStruct(rootA->right, rootB->right);
}
8.二叉树的镜像
二叉树镜像的概念就是左右子树交换，所以判断起来也很简单，代码如下：
/**
* judge the binary tree 'rootA' is a mirror of 'rootB' or not
*/
template<typename Type>
bool ISMirror(BiNode<Type> *rootA, BiNode<Type> *rootB)
{
if(rootA == NULL && rootB == NULL)
return true;
if(rootA == NULL || rootB == NULL)
return false;
if(rootA->data != rootB->data)
return false;
return ISMirror(rootA->left, rootB->right) && ISMirror(rootA->right, rootB->left);
}
如果将ISMirror递归部分换成如下的代码，就是判断两棵二叉树是否相同。
return ISMirror(rootA-<left, rootB-<left) && ISMirror(rootA-<right, rootB-<right);
9.平衡二叉树的判断
我们都知道平衡二叉树的定义：空树或左右子树的高度差不超过1，且左右子树也都是平衡二叉树。代码如下：
/**
* judge the binary tree whether it is a balanced tree
*/
template <typename Type>
bool IsBalanced(BiNode<Type> *root)
{
int height = 0;
return SubIsBalanced(root, height);
}
template <typename Type>
bool SubIsBalanced(BiNode<Type> *root, int &height)
{
if(root == NULL)
{
height = 0;
return true;
}
int lH, rH;
int result = SubIsBalanced(root->left, lH) && SubIsBalanced(root->right, rH);
if (result)
{
if(lH - rH <= 1 && lH - rH >= -1)
{
height = (lH > rH ? lH + 1 : rH + 1);
return true;
}
}
return false;
}
10.完全二叉树的判断
完全二叉树的定义如下：若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。判断一棵树是否是完全二叉树，我见过最简单的方法是：通过广度遍历即层次遍历的思想，将各个节点入队列，对于存在空洞的节点（ 左右孩子的节点存在NULL），把它的两个孩子也入队列，当访问到队列中为NULL的节点，根据完全二叉树的定义，此时二叉树已经结束，即队列中的其他元素全部为NULL，否则该树不是完全二叉树。代码如下：
/**
* judge the binary tree whether it is a balanced tree
*/
template <typename Type>
bool IsBalanced(BiNode<Type> *root)
{
int height = 0;
return SubIsBalanced(root, height);
}
template <typename Type>
bool SubIsBalanced(BiNode<Type> *root, int &height)
{
if(root == NULL)
{
height = 0;
return true;
}
int lH, rH;
int result = SubIsBalanced(root->left, lH) && SubIsBalanced(root->right, rH);
if (result)
{
if(lH - rH <= 1 && lH - rH >= -1)
{
height = (lH > rH ? lH + 1 : rH + 1);
return true;
}
}
return false;
}
11.满二叉树的判断
满二叉树的判断相对比较简单，可以通过判断每个节点的左右子树的高度是否相同来实现，满二叉树的所以节点的左右子树的高度都是一样的。代码如下：
/**
* judge the binary tree whether it is a completed tree
*/
template <typename Type>
bool IsCompletedBiTree(BiNode<Type> *root)
{
if(root == NULL)
return true;
queue<BiNode<Type> *> nodeQue;
nodeQue.push(root);
while(!nodeQue.empty())
{
BiNode<Type> *node = nodeQue.front();
nodeQue.pop();
if (node == NULL)
{
while (!nodeQue.empty())
{
if(nodeQue.front() != NULL)
return false;
nodeQue.pop();
}
return true;
}
nodeQue.push(node->left);
nodeQue.push(node->right);
}
//实际上不会执行到这一步
return true;
}
12.重建二叉树
根据二叉树的先序和中序遍历的结果（不含有重复的节点），重建此二叉树，该题的的解决思路也是通过二叉树递归定义的思想。我们知道二叉树先序遍历的一个节点，在中序遍历中会把以该节点为根的二叉树分为左右两部分，根据这点，可以递归的重建二叉树，具体代码如下：
/**
* rebuild the binary tree
*/
template <typename Type>
BiNode<Type> * RebuildBiTree(const Type *pre, const Type *in, int len)
{
if(pre == NULL || in == NULL || len <= 0)
return NULL;
BiNode<Type> * root = new BiNode<Type>;
root->data = pre[0];
int index;
for (index = 0; index < len; ++index)
{
if (in[index] == pre[0])
break;
}
//can not find the 'pre[0]' in the 'in[]'
if(index == len)
return NULL;
root->left = RebuildBiTree(pre + 1, in, index);
root->right = RebuildBiTree(pre + index + 1, in + index + 1, len - index - 1);
return root;
}
13.判断序列是否是二叉排序树的后序遍历序列
我们都知道二叉排序树的中序遍历的结果是一个递增序列，后序遍历序列最后的元素是根节点，通过最后的元素将遍历序列分割成两部分，左半部分都小于根节点的值，右半部分都大于该节点的值，如果不能分成这两部分，那么该序列就不是二叉排序树的后序遍历序列。代码如下：
/**
* judge the serial is post-order traversal of binary search tree
*/
template <typename Type>
bool IsBSTPostOrder(const Type *post, int len)
{
if(post == NULL || len <= 0)
return false;
int index;
//查找小于根节点的左子树节点
for (index = 0; index < len - 1; ++index)
{
if(post[index] > post[len - 1])
break;
}
//判断剩下的节点是否都为右子树的节点，即是否都大于根节点的值
for (int i = index; i < len - 1; ++i)
{
if(post[i] < post[len - 1])
return false;
}
bool result = true;
if(index > 0)
result = IsBSTPostOrder(post, index);
if(result && index < len - 1)
result = IsBSTPostOrder(post + index, len - index - 1);
return result;
}
就先写这么多吧，后面还会继续添加，累死了。。。
Sept 2nd - 3rd, 2013 @lab
