二叉树&线索二叉树算法与森林

1.二叉树

常见算法为：前/中/后序遍历二叉树（递归、非递归）及建立二叉链表、建立二叉树、层次遍历、复制二叉树、计算二叉树深度、统计二叉树节点等

1）

#include <iostream>
#include <cstdlib>
 
using namespace std;
 
// 二叉树链表的存储结构
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;
 
//二叉树的建立
void CreatBiTree(BiTree &T)
{
	char ch;
	cin >> ch;
	if (ch == '#')
		T = NULL;
	else
	{
		T = new BiTNode;
		if (!T)
			exit(1);
		T->data = ch;
		CreatBiTree(T->lchild);   // 构造左子树
		CreatBiTree(T->rchild);   // 构造右子树
	}
}
 
//前序遍历
void PreOrderTraverse(BiTree T)
{
	if (T)
	{
		cout << T->data;
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}	
}
 
// 中序遍历
void InOrderTraverse(BiTree T)
{
	if (T)
	{
		InOrderTraverse(T->lchild);
		cout << T->data;
		InOrderTraverse(T->rchild);
	}
}
//后序遍历
void PostOrderTraverse(BiTree T)
{
	if (T)
	{
		PostOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
		cout << T->data;
	}
}
int main()
{
	BiTree T;
	cout << "请输入建立二叉链表的序列：\n";
	CreatBiTree(T);
	
	cout << "前序排序：";
	PreOrderTraverse(T);
	cout << endl;
	
	cout << "中序排序：";
	InOrderTraverse(T);
	cout << endl;
	
	cout << "后序排序：";
	PostOrderTraverse(T);
	cout << endl;
	
	system("pause");
	
	return 0;
}

2）

#include<iostream>
#include <cstdlib>
 
using namespace std;
 
// 二叉树的二叉链表存储表示
typedef struct BiNode
{
	char data;						// 结点数据域
	struct BiNode *lchild, *rchild;	// 左右孩子指针
}BiTNode, *BiTree;
 
// 建立二叉链表
void CreateBiTree(BiTree &T)
{
	// 按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T
	char ch;
	cin >> ch;
 
	if (ch == '#')
		T = NULL;			//递归结束，建空树
	else
	{
		T = new BiTNode;
		T->data = ch;		// 生成根结点
		CreateBiTree(T->lchild); // 递归创建左子树
		CreateBiTree(T->rchild); // 递归创建右子树
	}
}// CreateBiTree
 
// 复制二叉树
void Copy(BiTree T, BiTree &NewT)
{
	if (T == NULL)
	{   		    // 如果是空树，递归结束
		NewT = NULL;
		return;
	}
	else
	{
		NewT = new BiTNode;
		NewT->data = T->data;	// 复制根结点
		Copy(T->lchild, NewT->lchild);   // 递归复制左子树
		Copy(T->rchild, NewT->rchild);  // 递归复制右子树
	}
}
 
// 计算二叉树深度
int Depth(BiTree T)
{
	int m, n;
 
	if (T == NULL)
		return 0;   //如果是空树，深度为0，递归结束
	else
	{
		m = Depth(T->lchild);  // 递归计算左子树的深度记为m
		n = Depth(T->rchild);  // 递归计算右子树的深度记为n
		if (m > n)
			return (m + 1);  // 二叉树的深度为m与n的较大者加1
		else
			return (n + 1);
	}
}
 
// 统计二叉树节点个数
int NodeCount(BiTree T)
{
	if (T == NULL) return 0;  // 如果是空树，则结点个数为0，递归结束
	else return NodeCount(T->lchild) + NodeCount(T->rchild) + 1;
	//否则结点个数为左子树的结点个数+右子树的结点个数+1
}
 
// 中序遍历的递归算法							
void InOrderTraverse(BiTree T)
{
	if (T) 
	{
		InOrderTraverse(T->lchild);
		cout << T->data;
		InOrderTraverse(T->rchild);
	}
}
 
int main()
{
	BiTree tree, new_tree;
	cout << "请输入建立二叉树的序列: \n";
	CreateBiTree(tree);
	Copy(tree, new_tree);
	cout << "复制得到的新树的中序序列: \n";
	InOrderTraverse(new_tree);
	cout << endl;
 
	cout << "二叉树的深度为: " << Depth(new_tree) << endl;
	cout << "二叉树的结点个数为: " << NodeCount(new_tree) << endl;
	
	system("pause");
 
	return 0;
}

2.线索二叉树

常见算法为：构造线索二叉树等。

c实现:

#include<iostream>
using namespace std;
 
// 二叉树的二叉线索类型存储表示
typedef struct BiThrNode
{
	char data;	// 结点数据域
	struct BiThrNode *lchild, *rchild;	// 左右孩子指针
	int LTag, RTag;
}BiThrNode, *BiThrTree;
 
//全局变量pre
BiThrNode *pre = new BiThrNode;
 
// 建立二叉链表
void CreateBiTree(BiThrTree &T)
{
	//按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T
	char ch;
	cin >> ch;
	
	if (ch == '#')  
		T = NULL;  // 递归结束，建空树
	else
	{
		T = new BiThrNode;
		T->data = ch;		     // 生成根结点
		CreateBiTree(T->lchild); // 递归创建左子树
		CreateBiTree(T->rchild); // 递归创建右子树
	}								
}									
 
// 以结点P为根的子树中序线索化
void InThreading(BiThrTree p)
{
	// pre是全局变量，初始化时其右孩子指针为空，便于在树的最左点开始建线索
	if (p)
	{
		InThreading(p->lchild);   // 左子树递归线索化
		if (!p->lchild)
		{                   	 // p的左孩子为空
			p->LTag = 1;        // 给p加上左线索
			p->lchild = pre;   // p的左孩子指针指向pre（前驱）
		}
		else
			p->LTag = 0;
		if (!pre->rchild)
		{					   // pre的右孩子为空
			pre->RTag = 1;     // 给pre加上右线索
			pre->rchild = p;  // pre的右孩子指针指向p（后继）
		}
		else
			pre->RTag = 0;
		pre = p;              // 保持pre指向p的前驱
		InThreading(p->rchild);  // 右子树递归线索化
	}
}
 
// 带头结点的中序线索化
void InOrderThreading(BiThrTree &Thrt, BiThrTree T)
{
	//中序遍历二叉树T，并将其中序线索化，Thrt指向头结点
	Thrt = new BiThrNode;   // 建头结点
	Thrt->LTag = 0;         // 头结点有左孩子，若树非空，则其左孩子为树根
	Thrt->RTag = 1;        // 头结点的右孩子指针为右线索
	Thrt->rchild = Thrt;   // 初始化时右指针指向自己
	if (!T)  
		Thrt->lchild = Thrt;   // 若树为空，则左指针也指向自己
	else
	{
		Thrt->lchild = T;  pre = Thrt; 	// 头结点的左孩子指向根，pre初值指向头结点
		InThreading(T);          // 对以T为根的二叉树进行中序线索化
		pre->rchild = Thrt;     // pre为最右结点，pre的右线索指向头结点
		pre->RTag = 1;
		Thrt->rchild = pre;   // 头结点的右线索指向pre
	}
} 						
 
void InOrderTraverse_Thr(BiThrTree T)
{
	//中序遍历二叉线索树T的非递归算法，对每个数据元素直接输出
	BiThrTree p;
	p = T->lchild;       // p指向根结点
	while (p != T)		// 空树或遍历结束时，p==T
	{
		while (p->LTag == 0) // 沿左孩子向下
			p = p->lchild;	 // 访问其左子树为空的结点
		cout << p->data;
		while (p->RTag == 1 && p->rchild != T)
		{
			p = p->rchild;	// 沿右线索访问后继结点
			cout << p->data;
		}
		p = p->rchild;
	}
}													
 
int main()
{
	pre->RTag = 1;
	pre->rchild = NULL;
	BiThrTree tree, Thrt;
	
	cout << "请输入建立二叉链表的序列：\n";
	CreateBiTree(tree);
	InOrderThreading(Thrt, tree);
	cout << "中序遍历线索二叉树的结果为：\n";
	InOrderTraverse_Thr(Thrt);
	cout << endl;
 
	system("pause");
 
	return 0;
}

参考：
https://blog.csdn.net/qq_22847457/article/details/95621193
https://blog.csdn.net/qq_22847457/article/details/95667505