面试算法之二叉树操作集锦

最新推荐文章于 2022-07-26 19:26:58 发布

walker沃克

最新推荐文章于 2022-07-26 19:26:58 发布

阅读量3.8k

点赞数 6

分类专栏： ALgorithm 文章标签：二叉树

本文链接：https://blog.csdn.net/anonymalias/article/details/10897009

版权

ALgorithm 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

开学了，找工作也正式拉开了序幕，每天光自己看书，也很没劲，和大家一起分享分享，交流一下笔试面试过程中的各种算法题目，如有问题，欢迎指正，希望大家一起进步。。。

下面是对数据结构二叉树的一些基本操作，可能在面试中都会涉及到。我们都知道二叉树的定义本身就是一种递归定义，所以对树的大部分操作都可以通过递归的方式进行，但递归不是万能的，因为递归的本身是一件很浪费内存资源的操作，所以在选择算法的时候要权衡各种因素，选取最合理的算法。下图Fig 1 是下面代码中举例会用到的图：

Fig 1

在本文中，所讨论的二叉树采取以下的定义方式：

template<typename Type>
struct 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)
        {
            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);

    return lHeight > rHeight ? lHeight + 1 : rHeight + 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.二叉树节点的个数

/**
 * calculate the tree's node counts
 */
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 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;
}

11.满二叉树的判断

满二叉树的判断相对比较简单，可以通过判断每个节点的左右子树的高度是否相同来实现，满二叉树的所以节点的左右子树的高度都是一样的。代码如下：

/**
 * judge the binary tree whether it is a full tree
 */
template <typename Type>
bool IsFullBiTree(BiNode<Type> *root)
{
	if(root == NULL)
		return true;

	int height;
	return SubIsFullBiTree(root, height);
}

template <typename Type>
bool SubIsFullBiTree(BiNode<Type> *root, int &height)
{
	if(root == NULL)
	{
		height = 0;
		return true;
	}

	int lH, rH;
	if (SubIsFullBiTree(root->left, lH) && SubIsFullBiTree(root->right, rH))
	{
		if (lH == rH)
		{
			height = lH + 1;
			return true;
		}
	}

	return false;
}

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;
}

就先写这么多吧，后面还会继续添加，累死了。。。
有新的问题大家可以提出来，一起讨论，共同进步...<^_^>。。。

14.二叉树结点间最大的距离

二叉树结点间最大距离的含义是指任意两个叶结点间路径条数的最大值。解决思路就是通过求二叉树高度的思想。在求高度的过程中，维持一个最大距离max，对每个结点的左右高度之和与max进行比较，如果大于max，那么就更新max的值。代码如下：

/**
 * calculate the maximum distance of the node in the binary search tree
 */

template <typename Type>
int MaxDistance(BiNode<Type> *root)
{
	if(root == NULL)
		return 0;
	
	int maxDis = 0;
	SubMaxDistance(root, maxDis);

	return maxDis;
}

template <typename Type>
int SubMaxDistance(BiNode<Type> *root, int &maxDis)
{
	if(root == NULL)
		return 0;

	int lH = SubMaxDistance(root->left, maxDis);
	int rH = SubMaxDistance(root->right, maxDis);

	if (lH + rH > maxDis)
	{
		maxDis = lH + rH;
	}

	return (lH > rH ? lH + 1 : rH + 1);
}

15.二叉树中路径和为给定值的所有路径

直接给代码。。。

/**
 * print all paths' sum is equal to K in binary search tree
 */
template <typename Type>
void PrintSumISKPath(BiNode<Type> *root, int k)
{
	if(root == NULL)
		return;

	vector<Type> vecNode;
	SubPrintSumISKPath(root, k, vecNode);
}

template <typename Type>
void SubPrintSumISKPath(BiNode<Type> *root, int k, vector<Type> &vecNode)
{
	if(root == NULL)
		return;

	k -= root->data;
	vecNode.push_back(root->data);

	if (root->left == NULL && root->right == NULL && k == 0)
	{
		for (int i = 0; i < vecNode.size(); ++i)
		{
			cout<<vecNode[i]<<" ";
		}
		cout<<endl;
	}

	SubPrintSumISKPath(root->left, k, vecNode);
	SubPrintSumISKPath(root->right, k, vecNode);

	vecNode.pop_back();
}

16.二叉树的最低公共祖先

最低公共祖先的解决思想就是在递归遍历的过程中，如果遇到目标结点，就一直在该结点到最低公共结点的路径上返回该结点，直到两个目标结点汇聚到最低公共结点，然后返回该最低公共结点，代码如下：

/**
 * print the lowest common ancestor
 */
template <typename Type>
BiNode<Type> * LCA(BiNode<Type> *root, BiNode<Type> *x, BiNode<Type> *y)
{
	if(root == NULL)
		return NULL;
	if(x == root || y == root)
		return root;

	BiNode<Type> *left = LCA(root->left, x, y);
	BiNode<Type> *right = LCA(root->right, x, y);

	if(left == NULL)
		return right;
	else if(right == NULL)
		return left;
	else
		return root;
}

Creation Date: Sept 2nd - 3rd, 2013 @lab

Last Modification Date: Oct 4, 2013 PM 23:28 @dorm

walker沃克

关注

6
点赞
踩
12

收藏

觉得还不错? 一键收藏
8
评论
面试算法之二叉树操作集锦

开学了，找工作也正式拉开了序幕，每天光自己看书，也很没劲，和大家一起分享分享，交流一下笔试面试过程中的各种算法题目，希望大家一起进步。。。下面是对数据结构二叉树的一些基本操作，可能在面试中都会涉及到。我们都知道二叉树的定义本身就是一种递归定义，所以对树的大部分操作都可以通过递归的方式进行，但递归不是万能的，因为递归的本身是一件很浪费内存资源的操作，所以在选择算法的时候要权衡各种因素，选取最合理
复制链接

扫一扫