06.02 二叉树遍历

一：知识点概述

按照根的访问顺序不同，根在前面称为先序遍历（DLR），根在中间称为中序遍历（LDR），根在最后称为后序遍历（LRD）。

二：先序遍历

A B D E C F G


A B C D E F G

三：中序遍历

D B E A F G C

B C D A F E J H I G

四：后序遍历

D E B G F C A

D C B F J I H G E A

五：层次遍历

A B C D E F G

A B E C F G D H J I

六：二叉树创建

七：二叉树还原—一定要有中序

例如：已知一棵二叉树的先序序列ABDECFG和中序序列DBEAFGC，画出这棵二叉树。

traverse.cpp

#include <iostream>
#include <queue>//引入队列头文件
using namespace std;

typedef struct Bnode	/*定义二叉树存储结构*/
{
	char data;
	struct Bnode* lchild, * rchild;
}Bnode, * Btree;

void Createtree(Btree& T)	/*创建二叉树函数*/
{
	//按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T
	char ch;
	cin >> ch;
	if (ch == '#')
		T = NULL;			//递归结束，建空树
	else {
		T = new Bnode;
		T->data = ch;					//生成根结点
		Createtree(T->lchild);	//递归创建左子树
		Createtree(T->rchild);	//递归创建右子树
	}
}

void preorder(Btree T)//先序遍历
{
	if (T)
	{
		cout << T->data << "  ";
		preorder(T->lchild);
		preorder(T->rchild);
	}
}

void inorder(Btree T)//中序遍历
{
	if (T)
	{
		inorder(T->lchild);
		cout << T->data << "  ";
		inorder(T->rchild);
	}
}

void posorder(Btree T)//后序遍历
{
	if (T)
	{
		posorder(T->lchild);
		posorder(T->rchild);
		cout << T->data << "  ";
	}
}

bool Leveltraverse(Btree T)
{
	Btree p;
	if (!T)
		return false;
	queue<Btree>Q; //创建一个普通队列(先进先出)，里面存放指针类型
	Q.push(T); //根指针入队
	while (!Q.empty()) //如果队列不空
	{
		p = Q.front();//取出队头元素作为当前扩展结点livenode
		Q.pop(); //队头元素出队
		cout << p->data << "  ";
		if (p->lchild)
			Q.push(p->lchild); //左孩子指针入队
		if (p->rchild)
			Q.push(p->rchild); //右孩子指针入队
	}
	return true;
}

int main()
{
	Btree mytree;
	cout << "按先序次序输入二叉树中结点的值（孩子为空时输入#），创建一棵二叉树" << endl;
	Createtree(mytree);//创建二叉树
	cout << endl;
	cout << "二叉树的先序遍历结果：" << endl;
	preorder(mytree);//先序遍历二叉树
	cout << endl;
	cout << "二叉树的中序遍历结果：" << endl;
	inorder(mytree);//中序遍历二叉树
	cout << endl;
	cout << "二叉树的后序遍历结果：" << endl;
	posorder(mytree);//后序遍历二叉树
	cout << endl;
	cout << "二叉树的层次遍历结果：" << endl;
	Leveltraverse(mytree);//层次遍历二叉树
	return 0;
}

PreinCreateBitree.cpp

#include <iostream>
using namespace std;
typedef struct node
{
	char data;
	struct node* lchild, * rchild;
}BiTNode, * BiTree;

BiTree pre_mid_createBiTree(char* pre, char* mid, int len) //前序中序还原建立二叉树
{
	if (len == 0)
		return NULL;
	char ch = pre[0];  //找到先序中的第一个结点
	int index = 0;
	while (mid[index] != ch)//在中序中找到的根结点的左边为该结点的左子树，右边为右子树
	{
		index++;
	}
	BiTree T = new BiTNode;//创建根结点
	T->data = ch;
	T->lchild = pre_mid_createBiTree(pre + 1, mid, index);//建立左子树
	T->rchild = pre_mid_createBiTree(pre + index + 1, mid + index + 1, len - index - 1);//建立右子树
	return T;
}

BiTree pro_mid_createBiTree(char* last, char* mid, int len)//后序中序还原建立二叉树
{
	if (len == 0)
		return NULL;
	char ch = last[len - 1]; //取得后序遍历顺序中最后一个结点
	int index = 0;//在中序序列中找根结点，并用index记录长度
	while (mid[index] != ch)//在中序中找到根结点，左边为该结点的左子树，右边为右子树
		index++;
	BiTree T = new BiTNode;//创建根结点
	T->data = ch;
	T->lchild = pro_mid_createBiTree(last, mid, index);//建立左子树
	T->rchild = pro_mid_createBiTree(last + index, mid + index + 1, len - index - 1);//建立右子树
	return T;
}

void pre_order(BiTree T)//前序递归遍历二叉树
{
	if (T)
	{
		cout << T->data;
		pre_order(T->lchild);
		pre_order(T->rchild);
	}
}

void pro_order(BiTree T)//后序递归遍历二叉树
{
	if (T)
	{
		pro_order(T->lchild);
		pro_order(T->rchild);
		cout << T->data;
	}
}
int main()
{
	BiTree T;
	int n;
	char pre[100], mid[100], last[100];
	cout << "1. 前序中序还原二叉树\n";
	cout << "2. 后序中序还原二叉树\n";
	cout << "0. 退出\n";
	int choose = -1;
	while (choose != 0)
	{
		cout << "请选择:";
		cin >> choose;

		switch (choose)
		{
		case 1://前序中序还原二叉树
			cout << "请输入结点的个数:" << endl;
			cin >> n;
			cout << "请输入前序序列:" << endl;
			for (int i = 0; i < n; i++)
				cin >> pre[i];
			cout << "请输入中序序列:" << endl;
			for (int i = 0; i < n; i++)
				cin >> mid[i];
			T = pre_mid_createBiTree(pre, mid, n);
			cout << endl;
			cout << "二叉树还原成功，输出其后序序列:" << endl;
			pro_order(T);
			cout << endl << endl;
			break;
		case 2://后序中序还原二叉树
			cout << "请输入结点的个数:" << endl;
			cin >> n;
			cout << "请输入后序序列:" << endl;
			for (int i = 0; i < n; i++)
				cin >> last[i];
			cout << "请输入中序序列:" << endl;
			for (int i = 0; i < n; i++)
				cin >> mid[i];
			T = pro_mid_createBiTree(last, mid, n);
			cout << endl;
			cout << "二叉树还原成功，输出其先序序列:" << endl;
			pre_order(T);
			cout << endl << endl;
			break;
		}
	}
	return 0;
}