二叉树题目小结

1. 求二叉树中的节点个数

2. 求二叉树的深度

3. 前序遍历，中序遍历，后序遍历

4. 分层遍历二叉树（按层次从上往下，从左往右）

5. 将二叉查找树变为有序的双向链表

6. 求二叉树第K层的节点个数

7. 求二叉树中叶子节点的个数

8. 判断两棵二叉树是否结构相同

9. 判断二叉树是不是平衡二叉树

10. 求二叉树的镜像

11. 判断二叉树是不是完全二叉树

12. 求二叉树中两个节点的最低公共祖先节点

13. 求二叉树中任意两个节点的距离

二叉树节点定义：

typedef char ElemType;

typedef struct BinTreeNode {
	ElemType value;
	BinTreeNode *left;
	BinTreeNode *right;
	BinTreeNode(ElemType val) : value(val), left(NULL), right(NULL) {}
}BinTreeNode, *BinTree;

1. 求二叉树中的节点个数

递归解法：
（1）如果二叉树为空，节点个数为0
（2）如果二叉树不为空，二叉树节点个数 = 左子树节点个数 + 右子树节点个数 + 1

int GetNodeNum(BinTree pRoot) {
	if (pRoot == NULL)
		return 0;  
    return GetNodeNum(pRoot->left) + GetNodeNum(pRoot->right) + 1;  
}

2. 求二叉树的深度

递归解法：
（1）如果二叉树为空，二叉树的深度为0
（2）如果二叉树不为空，二叉树的深度 = max(左子树深度， 右子树深度) + 1

int GetDepth(BinTree pRoot) {  
    if (pRoot == NULL) // 递归出口  
        return 0;  
    int leftDepth = GetDepth(pRoot->left);  
    int rightDepth = GetDepth(pRoot->right);  
    return leftDepth > rightDepth ? (leftDepth + 1) : (rightDepth + 1);   
}

3. 前序遍历，中序遍历，后序遍历

4. 分层遍历二叉树（按层次从上往下，从左往右）

http://blog.youkuaiyun.com/atinybirdinit/article/details/44034165

5. 将二叉查找树变为有序的双向链表

http://blog.youkuaiyun.com/ljianhui/article/details/22338405

6. 求二叉树第K层的节点个数

递归解法：
（1）如果二叉树为空或者k<1，返回0
（2）如果二叉树不为空并且k==1，返回1
（3）如果二叉树不为空且k>1，返回左子树中k-1层的节点个数与右子树k-1层节点个数之和

int GetNodeNumKthLevel(BinTree pRoot, int k) {  
    if (pRoot == NULL || k < 1)  
        return 0;  
    if (k == 1)  
        return 1;  
    int leftNum = GetNodeNumKthLevel(pRoot->left, k - 1); // 左子树中k-1层的节点个数  
    int rightNum = GetNodeNumKthLevel(pRoot->right, k - 1); // 右子树中k-1层的节点个数  
    return (leftNum + rightNum);  
}

7. 求二叉树中叶子节点的个数

递归解法：
（1）如果二叉树为空，返回0
（2）如果二叉树不为空且左右子树为空，返回1
（3）如果二叉树不为空，且左右子树不同时为空，返回左子树中叶子节点个数加上右子树中叶子节点个数

int GetLeafNodeNum(BinTree pRoot) {  
    if (pRoot == NULL)  
        return 0;  
    if (pRoot->left == NULL && pRoot->right == NULL)  
        return 1;  
    int leftNum = GetLeafNodeNum(pRoot->left); // 左子树中叶节点的个数  
    int rightNum = GetLeafNodeNum(pRoot->right); // 右子树中叶节点的个数  
    return (leftNum + rightNum);  
}

8. 判断两棵二叉树是否结构相同

不考虑数据内容。结构相同意味着对应的左子树和对应的右子树都结构相同。
递归解法：
（1）如果两棵二叉树都为空，返回真
（2）如果两棵二叉树一棵为空，另一棵不为空，返回假
（3）如果两棵二叉树都不为空，如果对应的左子树和右子树都同构返回真，其他返回假

bool StructureCmp(BinTree pRoot1, BinTree pRoot2) {  
    if (pRoot1 == NULL && pRoot2 == NULL) // 都为空，返回真  
        return true;  
    else if (pRoot1 == NULL || pRoot2 == NULL) // 有一个为空，一个不为空，返回假  
        return false;  
    bool leftResult = StructureCmp(pRoot1->left, pRoot2->left); // 比较对应左子树   
    bool rightResult = StructureCmp(pRoot1->right, pRoot2->right); // 比较对应右子树  
    return (leftResult && rightResult);  
}

9. 判断二叉树是不是平衡二叉树

递归解法：
（1）如果二叉树为空，返回真
（2）如果二叉树不为空，如果左子树和右子树都是AVL树并且左子树和右子树高度相差不大于1，返回真，其他返回假

bool IsAVL(BinTree pRoot, int &height) {  
	if(pRoot == NULL) { // 空树，返回真  
        height = 0;  
        return true;  
    }
    int leftHeight;
    bool leftResult = IsAVL(pRoot->left, leftHeight);  
    int rightHeight;  
    bool rightResult = IsAVL(pRoot->right, rightHeight);  
    if(leftResult && rightResult && abs(leftHeight - rightHeight) <= 1) { // 左子树和右子树都是AVL，并且高度相差不大于1，返回真  
        height = max(leftHeight, rightHeight) + 1;  
        return true;  
    } else {  
        height = max(leftHeight, rightHeight) + 1;  
        return false;  
    }
}

10. 求二叉树的镜像

递归解法：
（1）如果二叉树为空，返回空
（2）如果二叉树不为空，求左子树和右子树的镜像，然后交换左子树和右子树

BinTree Mirror(BinTree pRoot) {  
    if(pRoot == NULL) // 返回NULL  
        return NULL; 
    BinTreeNode *pLeft = Mirror(pRoot->left); // 求左子树镜像  
    BinTreeNode *pRight = Mirror(pRoot->right); // 求右子树镜像  
        // 交换左子树和右子树  
    pRoot->left = pRight;  
    pRoot->right = pLeft;  
    return pRoot;
}

11.判断二叉树是不是完全二叉树

如果一棵二叉树至多只有最下面的两层节点度数可以小于2，并且最下面一层的节点都集中在该层最左边的若干位置上，则此二叉树称为“完全二叉树”。
有如下算法，按层次（从上到下，从左到右）遍历二叉树，当遇到一个节点的左子树为空时，则该节点右子树必须为空，且后面遍历的节点左右子树都必须为空，否则不是完全二叉树。

bool IsCompleteBinTree(BinTree pRoot) {
    if(pRoot == NULL)
        return false;
    queue<BinTreeNode *> q;
    q.push(pRoot);
    bool mustHaveNoChild = false;
    bool result = true;
    while(!q.empty()) {
        BinTreeNode *pNode = q.front();
        q.pop();
        if(mustHaveNoChild) { // 已经出现了有空子树的节点了，后面出现的必须为叶节点（左右子树都为空）  
            if(pNode->left != NULL || pNode->right != NULL) {
                result = false;
                break;  
            }
        } else {
            if(pNode->left != NULL && pNode->right != NULL) {
                q.push(pNode->left);  
                q.push(pNode->right);  
            } else if(pNode->left != NULL && pNode->right == NULL) {
                mustHaveNoChild = true;  
                q.push(pNode->left);  
            } else if(pNode->left == NULL && pNode->right != NULL) {
                result = false;  
                break;  
            } else {
                mustHaveNoChild = true;
            }
        }
    }
    return result;
}

12. 求二叉树中两个节点的最低公共祖先节点

从root开始遍历，如果n1和n2中的任一个和root匹配，那么root就是LCA；
如果都不匹配，则分别递归左、右子树，如果有一个（n1或n2）出现在左子树，并且另一个（n1或n2）出现在右子树，则root就是LCA；
如果两个key都出现在左子树，则说明LCA在左子树中，否则在右子树。

BinTreeNode *FindLCA(BinTree pRoot, BinTreeNode *n1, BinTreeNode *n2) {
	if (pRoot == NULL) 
		return NULL;
		
	// 只要n1 或 n2 的任一个匹配即可
    if (pRoot->value == n1->value || pRoot->value == n2->value)
        return pRoot;
    
    // 分别在左右子树查找
    BinTreeNode *leftLCA  = FindLCA(pRoot->left, n1, n2);
    BinTreeNode *rightLCA = FindLCA(pRoot->right, n1, n2);
    
    // 如果都返回非空指针, 则说明两个节点分别出现了在两个子树中，则当前节点肯定为LCA
    if (leftLCA && rightLCA)  
    	return pRoot;
    
    // 如果一个为空，在说明LCA在另一个子树
    return (leftLCA != NULL) ? leftLCA : rightLCA;
}

13. 求二叉树中任意两个节点的距离

先求这两个节点的最低公共祖先节点；
然后求最低公共祖先节点以及所求两节点到根节点的深度；
最后利用公式：所求两节点的深度和 - 2倍最低公共祖先节点的深度

int FindLevel(BinTree pRoot, BinTreeNode *node){
	if(pRoot == NULL) 
       	return -1;
       
    if(pRoot->value == node->value) 
        return 0;
        	
    //先在左子树查找
    int level = FindLevel(pRoot->left, node);
        
    //左子树没有找到则到右子树查找
    if(level == -1){
        level = FindLevel(pRoot->right, node);
    }
        
    if(level != -1)
        return level+1;
    return -1;
}

int GetTreeNodesDistance(BinTree pRoot, BinTreeNode *n1, BinTreeNode *n2) {
	BinTreeNode *nodeLCA = FindLCA(pRoot, n1, n2);
	int disLCA = FindLevel(pRoot, nodeLCA);
	int dis1 = FindLevel(pRoot, n1);
	int dis2 = FindLevel(pRoot, n2);
	return dis1 + dis2 - 2 * disLCA; 
}

本文参考自 http://blog.youkuaiyun.com/luckyxiaoqiang/article/details/7518888