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