二叉树的遍历 C/C++语言实现

目录

1、二叉树的定义

2、二叉树的遍历

2.1、先序遍历

递归版

非递归版

2.2、中序遍历

递归版

非递归版

2.3、后序遍历

递归版

非递归版

2.4、层序遍历

3、二叉树的创建

4、二叉树的销毁

---

1、二叉树的定义

二叉树包括数据域，左孩子，右孩子。如果要要方便找双亲节点还可以添加一个指针（这里没有）

typedef int TElemType;
typedef struct BitNode
{
	TElemType data;
	BitNode *lchild, *rchild;
}BitNode,*BitTree;

2、二叉树的遍历

二叉树的遍历是其他操作的基础，其他很多修改创建的操作，都是建立在二叉树的遍历的基础上的。

二叉树的遍历包括：先序遍历（图的DFS）、中序遍历、后序遍历、层序遍历（图的BFS）

后面的遍历实现都通过最简单的输出结点数据域来展示。其他操作操作都是在该基础修改来实现

下面几棵树为测试数据，可以作为参考使用：

/*
树 t1
            1
          /    \
        2        3
      /    \
    4        5
            /\
          6      7

输入：
1 2 4 -1 -1 5 6 7 -1 -1 -1 -1 3 -1 -1
先序 1 2 4 5 6 7 3
中序 4 2 6 5 7 1 3
后续 4 6 7 5 2 3 1

 

树 t2
            1
          /    \
        2        3
      /    \
    4        5
            /   \
          6      7
          /  \
        1    2

输入：
1 2 4 -1 -1 5 6  1 -1 -1 2 -1 -1 7 -1 -1 3 -1 -1
先序 1 2 4 5 6 1 2 7 3
中序 4 2 1 6 2 5 7 3 1
后序 4 1 2 6 7 5 2 3 1
树 t3

                6
               / \
             3     9
           /  \       / \
         1     4   7   10
          \        \    \    \
           2       5   8   11

输入：
6 3 1 -1 2 -1 -1 4 -1 5 -1 -1 9 7 -1 8 -1 -1 10 -1 11 -1 -1
先序 6 3 1 2 4 5 9 7 8 10 11
中序 1 2 3 4 5 6 7 8 9 10 11
后序 2 1 5 4 3 8 7 11 10 9 6

*/

2.1、先序遍历

先序遍历访问顺序： 根结点->左孩子->右孩子。

左孩子本身可以看作另外一棵树，如果还有左右孩子，也按该顺序进行遍历。

根节点非空，打印根节点内容，递归左子树，递归右子树

递归版

void PreOrderTraverse(BitTree T)
{
	if (T)
	{
		cout << T->data << " ";
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
}

非递归版

sta栈记录工作指针。p指向当前访问结点，当前结点非空，打印该结点，将当前指着保存到栈中，进入右子树

否则到达叶子结点，回溯，弹出栈顶，进入右子树。

void RePreOrderTraverse(BitTree T)
{
	stack<BitNode*> sta;
	BitNode *p = T;
	BitNode *t;//临时存储弹出元素
	while (p || !sta.empty())
	{
		if (p)
		{
			cout << p->data << " ";//输出当前节点
			sta.push(p);//保存当前结点
			p = p->lchild;//进入左子树
		}
		else//左子树遍历完成
		{
			t = sta.top();//回到上层结点
			sta.pop();//弹出该层
			p = t->rchild;//进入右子树
		}
	}

}

2.2、中序遍历

中序遍历访问顺序： 左孩子->根结点->右孩子。

递归版

void InOrderTraverse(BitTree T)
{
	if (T)
	{
		InOrderTraverse(T->lchild);
		cout << T->data << " ";
		InOrderTraverse(T->rchild);
	}

非递归版

void ReInOrderTraverse(BitTree T)
{
	stack<BitNode*> sta;
	BitNode *p = T;
	BitNode *q;
	while (p || !sta.empty())//当前树或栈未空
	{
		if (p)
		{
			sta.push(p);//保存当前结点
			p = p->lchild;//进入左子树
		}
		else//左子树访问完成
		{
			q=sta.top();//获取上一层
			sta.pop();//弹出
			cout << q->data << " ";//访问根节点
			p = q->rchild;//进入右子树
		}
	}
}

2.3、后序遍历

后序遍历访问顺序： 左孩子->右孩子->根结点。

递归版

void PostOrderTraverse(BitTree T)
{
	if (T)
	{
		PostOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
		cout << T->data << " ";
	}
}

非递归版

void RePostOrderTraverse(BitTree T)
{
	stack<BitNode*> sta;
	map<BitNode*,int> tag;
	BitNode* p = T;
	BitNode* t;
	while (p || !sta.empty())
	{
		if (p)
		{
			tag[p] = 1;
			sta.push(p);//保存当前层
			p = p->lchild;//进入左子树
		}
		else//左子树遍历完成
		{
			t = sta.top();
			if (!t->rchild)//没有右子树,说明到达了终端
			{
				cout << t->data << " ";//打印终端
				sta.pop();
				p = t->rchild;
			}
			else {//是根节点
				if (tag[t] == 1)//第二次访问
				{
					tag[t] = 2;
					p=t->rchild;
				}
				else if(tag[t]==2)
				{
					cout << t->data << " ";
					sta.pop();//退栈，回到上一层
					p = NULL;
				}
			}
		}
	}
}

2.4、层序遍历

层序遍历，即一层一层的访问二叉树，所有父节点访问后，访问其子节点，二叉树的层序遍历是通过队列实现的，所以不能通过函数递归(系统生成栈)的方式实现。

void Sequencetrav(BitTree t)
{
	BitNode *p;
	queue<BitNode*> que;
	que.push(t);
	while (!que.empty())//队列非空
	{
		p = que.front();//获取队首
        cout << p->data << " ";
		que.pop();
		if (p->lchild)//有左子树，入队 
			que.push(p->lchild);
		if (p->rchild)//有右子树，入队
			que.push(p->rchild);
	}
}

3、二叉树的创建

二叉树的创建，如果存在左子树或右子树为空的情况，我们需要有能够代表空的标签来填补上。

如创建int型，这里我假设全是自然数，我可以让 -1作为空的标签

void CreateBitTree(BitTree & T)
{
	int c;
	cin >> c;
	if (c == -1)//-1，为空结点
		T = nullptr;
	else
	{
    //否则创建结点，同时递归创建
		T = new BitNode;
		T->data = c;
		CreateBitTree(T->lchild);
		CreateBitTree(T->rchild);
	}
}

4、二叉树的销毁

递归，先销毁左子树，然后销毁右子树，然后销毁根节点

void DestoryTree(BitTree & t)
{
	if (t){
		DestoryTree(t->lchild);
		DestoryTree(t->rchild);
		delete[] t;
		t = nullptr;
	}
}

二叉树的增删操作都是在二叉树的遍历基础上实现，这里不在细致阐述。