二叉树遍历（递归算法和非递归算法）

于 2013-07-05 21:50:35 发布
阅读量864 收藏
点赞数
分类专栏： 数据结构 文章标签： 算法 数据结构 二叉树遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ARLoverKang/article/details/9255379
版权

用图形的方式来表现二叉树的结构，非常直观，也容易理解。但是，对于计算机来说，只能处理线性序列，因此需要通过遍历将树中的结点变成某种意义的线性序列。二叉树的遍历是指按照一定次序访问二叉树中的所有节点，且每个节点仅被访问一次的过程。是最基本的运算，是其他运算的基础。

二叉树的遍历方式：先序遍历，中序遍历，后序遍历和层次遍历。

可以通过递归和迭代来实现二叉树各种次序的遍历，
  迭代有两方法：
      （1） 用栈来存储结点信息；
      （2） 增加指向双亲结点的双亲指针；

先序遍历：

递归算法：

void PreOrderTraverse_Recursion(BinTree T)
{
	if (T)
	{
		// 访问根结点
		Visit(T);

		// 遍历左子树
		PreOrderTraverse_Recursion(T->lChild);

		// 遍历右子树
		PreOrderTraverse_Recursion(T->rChild);
	}

	// 空树返回
	return ;
}


非递归算法：

栈实现Version_1：

void PreOrderTraverse_Iteration1(BinTree T)  // 栈实现
{// 结点入栈时访问
    int top = -1; // 栈顶
    BinTNode *stack[MAX_SIZE];  // 保存结点指针信息的栈

    BinTNode *p = T; // 当前指针指向根结点

    // 当前指针为空且栈为空时，遍历结束
    while (p!=NULL || top!=-1) // !(p==NULL && top==-1)
    {
        while (p != NULL)
        {
            // 访问结点
            Visit(p);
            // 结点指针入栈
            stack[++top] = p;
            // 将左子树的根结点置为当前结点
            p = p->lChild;
        }

        if (top != -1)
        {
            // 弹出栈顶，并将栈顶的右子树置为当前结点
            p = stack[top--]->rChild;
        }
    }

    // 遍历结束，返回
    return ;
}

栈实现Version_2：

void PreOrderTraverse_Iteration2(BinTree T) // 栈实现
{
    if (T)
    {
        int top = -1; // 栈顶
        BinTNode *stack[MAX_SIZE]; // 保存结点指针信息的栈

        stack[++top] = T; // 根结点入栈
        while (top != -1)
        {
            // 弹出栈顶
            BinTNode *p = stack[top--];
            // 访问结点
            Visit(p);

            if (p->rChild)
            {
                // 右子树根结点入栈
                stack[++top] = p->rChild;
            }
            if (p->lChild)
            {
                // 左子树根结点入栈
                stack[++top] = p->lChild;
            }
        }
    }

    return ;
}

双亲指针实现Version_1：

void PreOrderTraverse_Iteration3(BinTree T) // 双亲指针实现
{
	BinTNode *p = T; // 当前结点指针
	BinTNode *q = NULL; // 当前结点的双亲结点指针

	while (p || q)
	{
		// 从根结点开始，沿左子树遍历，直至左子树为空
		while (p)
		{
			// 访问结点
			Visit(p);
			q = p;
			p = p->lChild;
		}

		// 结点q为叶结点，则沿左子树回溯
		while (q && q->rChild==NULL && q->parent && q==q->parent->lChild)
		{
			q = q->parent;
		}

		if (q)
		{
			if (q->rChild) // 存在右子树，则遍历右子树
			{
				p = q->rChild;
			} 
			else // 无右子树
			{
				// 沿右子树回溯
				while (q && q->parent && q==q->parent->rChild)
				{
					q = q->parent;
				}
				q = q->parent;
				if (q)
				{
					p = q->rChild;
				}
			}
		}
	}

	return ;
}

双亲指针实现Version_2：

void PreOrderTraverse_Iteration4(BinTree T) // 增加访问标志
{
	BinTNode *p = T;

	while (p)
	{
		if (p->bVisited == false)
		{
			Visit(p);
			p->bVisited = true;
		}
		// 左子树
		if (p->lChild && p->lChild->bVisited==false)
		{
			p = p->lChild;
		}
		// 右子树
		else if (p->rChild && p->rChild->bVisited==false)
		{
			p = p->rChild;
		}
		// 回溯到上一层
		else
		{
			p = p->parent;
		}
	}

	return ;
}

采用双亲指针实现关键在于回溯。为了回溯增加指向父亲节点的指针，以及是否已经访问的标志位，增加的空间复杂度为O(n)。时间方面，每个节点被访问一次。但是，当由叶子节点跳到下一个要访问的节点时，需要先回溯至父亲节点，再判断是否存在没有被访问过的右子树，如果没有，则继续回溯，直至找到一颗没有被访问过的右子树，这个过程需要很多的时间。每个叶子节点的回溯需要O(h)时间复杂度，叶子节点最多为(2^(h-1))，因此回溯花费的上限为O(h*(2^(h-1))。这个上限应该可以缩小。双亲指针实现唯一的好处是不需要额外的数据结构-栈。



中序遍历：

递归算法：

void InOrderTraverse_Recursion(BinTree T)
{
	if (T)
	{
		// 遍历左子树
		InOrderTraverse_Recursion(T->lChild);

		// 访问根结点
		Visit(T);

		// 遍历右子树
		InOrderTraverse_Recursion(T->rChild);
	}

	// 空树返回
	return ;
}


非递归算法：

栈实现：

void InOrderTraverse_Iteration1(BinTree T) // 栈实现
{// 结点出栈时访问
	int top = -1; // 栈顶
	BinTNode *stack[MAX_SIZE]; // 保存结点指针信息的栈

	BinTNode *p = T; // 当前指针指向根结点
	// 当前指针为空且栈为空时，遍历结束
	while (p!=NULL || top!=-1) // !(p==NULL && top==-1)
	{
		while (p != NULL)
		{
			// 结点指针进栈
			stack[++top] = p;
			// 将左子树的根结点置为当前结点
			p = p->lChild;
		}

		if (top != -1)
		{
			// 弹出栈顶
			p = stack[top--];
			// 访问结点
			Visit(p);
			// 将右子树的根结点置为当前结点
			p = p->rChild;
		}
	}

	// 遍历结束，返回
	return ;
}

双亲指针实现：

void InOrderTraverse_Iteration2(BinTree T) // 双亲指针实现
{
	BinTNode *p = T;
	while (p!=NULL)
	{
		// 沿左子树向下搜索当前子树尚未访问的最左结点
		while (p->lChild!=NULL && p->lChild->bVisited==false)
		{
			p = p->lChild;
		}

		// 访问未访问的最左结点
		if (p->bVisited == false)
		{
			Visit(p);
			p->bVisited = true;
		}

		if (p->rChild!=NULL && p->rChild->bVisited==false)
		{
			// 遍历当前结点的右子树
			p = p->rChild;
		}
		else
		{
			// 回溯至双亲结点
			p = p->parent;
		}
	}

	return ;
}



后序遍历：

递归算法：

void PostOrderTraverse_Recursion(BinTree T)
{
	if (T)
	{
		// 遍历左子树
		PostOrderTraverse_Recursion(T->lChild);

		// 遍历右子树
		PostOrderTraverse_Recursion(T->rChild);

		// 访问根结点
		Visit(T);
	}

	// 空树返回
	return ;
}


非递归算法：

栈实现Version_1：

void PostOrderTraverse_Iteration1(BinTree T) // 栈实现
{ // 结点两次出现在栈顶方可访问
	int top = -1; // 栈顶
	BinTNode *stack[MAX_SIZE]; // 保存结点指针信息的栈
	bool isFirst[MAX_SIZE]; // 标识结点出现在栈顶的次数（也可以对结点重新封装，定义在结点的结构体中）

	BinTNode *p = T; // 当前结点指针指向根结点
	while (p!=NULL || top!=-1)
	{
		while (p!=NULL)
		{
			// 结点入栈
			++top;
			stack[top] = p;
			// 更新标识
			isFirst[top] = true;
			// 将左子树的根结点置为当前结点
			p = p->lChild;
		}

		if (top != -1)
		{
			// 获取栈顶
			p = stack[top];

			// 判断栈顶结点的标识
			if (isFirst[top] == true)
			{
				isFirst[top] = false;
				// 遍历右子树
				p = p->rChild;
			} 
			else
			{
				// 弹出栈顶
				p = stack[top--];
				// 访问结点
				Visit(p);
				// 指针p置空,以便取出下一个结点
				p = NULL;
			}
		}
	}

	return ;
}

栈实现Version_2：

void PostOrderTraverse_Iteration2(BinTree T) // 栈实现
{
	int top = -1; // 栈顶
	BinTNode *stack[MAX_SIZE]; // 保存结点指针信息的栈

	BinTNode *p = T; // 根结点置为当前结点
	BinTNode *pre = NULL; // 前一次访问的结点

	// 根结点入栈
	if (p)
	{
		stack[++top] = p;
	}

	while (top!=-1)
	{
		p = stack[top];

		// 访问结点：（1）左右子树均为空；（2）前一个访问结点尾该结点的左孩子或右孩子
		if ((p->lChild==NULL && p->rChild==NULL) || 
			(pre!=NULL && (pre==p->lChild || pre==p->rChild)))
		{
			Visit(p);
			top--;
			pre = p;
		} 
		else
		{
			// 右子树
			if (p->rChild != NULL)
			{
				stack[++top] = p->rChild;
			}

			// 左子树
			if (p->lChild != NULL)
			{
				stack[++top] = p->lChild;
			}
		}
	}

	return ;
}



层次遍历：

void LevelTraverse(BinTree T)
{
	int front, rear; // 队头、队尾指针
	BinTNode *queue[MAX_SIZE]; // 保存结点指针信息的队列
	front = rear = 0;

	BinTNode *p = T;
	// 根结点入队
	if (p)
	{
		queue[rear] = p;
		rear = (rear+1)%MAX_SIZE;
	}

	while (rear != front)
	{
		// 队头出队
		p = queue[front];
		front = (front+1)%MAX_SIZE;
		// 访问结点
		Visit(p);
		// 左子树
		if (p->lChild)
		{
			queue[rear] = p->lChild;
			rear = (rear+1)%MAX_SIZE;
		}
		// 右子树
		if (p->rChild)
		{
			queue[rear] = p->rChild;
			rear = (rear+1)%MAX_SIZE;
		}
	}

	return ;
}



小结：

用栈来实现比增加指向父节点指针回溯更方便；

采用第一个思想，就是跟踪指针移动 用栈保存中间结果的实现方式，先序与中序难度一致，后序很困难。先序与中序只需要修改一下访问的位置即可。

采用第二个思想，直接用栈来模拟递归，先序非常简单；而中序与后序难度一致。先序简单是因为节点可以直接访问，访问完毕后无需记录。而中序与后序时，节点在弹栈后还不能立即访问，还需要等其他节点访问完毕后才能访问，因此节点需要设置标志位来判定，因此需要额外的O(n)空间。


ARLoverKang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值