目录
1. 二叉树的顺序存储结构
#define MAXSIZE 100
typedef char ElemType;
typedef ElemType BiTree[MAXSIZE];
#include <iostream>
int main()
{
BiTree bt; // 实例化一个二叉树
// 用一维数组存储二叉树的结点
int n;
std::cout << "Please enter Tree Node Number:" << std::endl;
std::cin >> n;
bt[0] = '#';
std::cout << "Please enter Tree Element " << std::endl;
for (int i = 1; i <= n; ++i)
std::cin >> bt[i];
for (auto c : bt)
std::cout << c << " ";
std::cout << std::endl;
return 0;
}
2.二叉树的链式存储
typedef struct BiTree
{
ElementType data;// 数据域
struct BiTree *lchild;// 指向左孩子
struct BiTree *rchild;// 指向右孩子
}BiTNode,*BiTree;
3.二叉树先序建立(先序遍历+中序遍历+后序遍历)
#include <iostream>
typedef struct BiTreeNode{
char data;
struct BiTreeNode *lchild;
struct BiTreeNode *rchild;
}*BiTree;
//按照先序遍历方法生成二叉树
void CreateBiTree(BiTree&);
//先序遍历二叉树
void PreOrderTraverse(const BiTree&);
//中序遍历二叉树
void InOrderTraverse(const BiTree&);
//后序遍历二叉树
void PostOrderTraverse(const BiTree&);
int main()
{
BiTree T;// 生成空二叉树
CreateBiTree(T);//创建二叉树
PreOrderTraverse(T);//先序遍历二叉树
InOrderTraverse(T);//中序遍历二叉树
PostOrderTraverse(T);//后序遍历二叉树
return 0;
}
void CreateBiTree(BiTree& T)
{
// 1.从键盘输入二叉树结点信息
char ch;
std::cin >> ch;
// 2.建立二叉树先序方式
if (ch == '#')
T = NULL;
else{
T = new BiTreeNode;
T->data = ch;// 生成根结点
CreateBiTree(T->lchild);// 建立左子树
CreateBiTree(T->rchild);// 建立右子数
}
return;
}
void PreOrderTraverse(const BiTree& T)
{
if (T!= NULL)
{
std::cout << T->data << " ";
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
return;
}
void InOrderTraverse(const BiTree& T)
{
if (T!= NULL)
{
InOrderTraverse(T->lchild);
std::cout << T->data << " ";
InOrderTraverse(T->rchild);
}
return;
}
void PostOrderTraverse(const BiTree& T)
{
if (T!= NULL)
{
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
std::cout << T->data << " ";
}
return;
}
4.二叉树的层次遍历
#include <iostream>
#define MAXSIZE 100
// 二叉树的链式存储结构
typedef struct BiTreeNode
{
char data;
struct BiTreeNode *lchild;
struct BiTreeNode *rchild;
}*BiTree;
// 顺序存储方式建立队列
struct Deque
{
BiTree de_data[MAXSIZE];
int front, rear;
};
// 先序遍历方式建立二叉树
void CreateBiTree(BiTree &);
// 层次遍历二叉树
// 使用队列遍历二叉树,因此需要先建立队列
// 初始化队列
void InitDeque(Deque &);
// 入队
void EnQueue(Deque &, const BiTree &);
// 判断队列是否为空
bool IsEmptyQueue(Deque &);
// 出队
void DeQueue(Deque &, BiTree &);
// 层次遍历二叉树
void LeveTraverse(BiTree &);
int main()
{
BiTree T;
CreateBiTree(T);
// // 测试队列
// Deque Q;
// InitDeque(Q);
// EnQueue(Q, 'a');
// std::cout << DeQueue(Q) << std::endl;
LeveTraverse(T);
return 0;
}
void CreateBiTree(BiTree& T)
{
// 1.从键盘输入二叉树结点信息
char ch;
std::cin >> ch;
// 2.建立二叉树先序方式
if (ch == '#')
T = NULL;
else{
T = new BiTreeNode({' ', nullptr, nullptr});
// std::cout << T->lchild << " " << T->rchild << std::endl;
T->data = ch;// 生成根结点
CreateBiTree(T->lchild);// 建立左子树
CreateBiTree(T->rchild);// 建立右子数
}
return;
}
void InitDeque(Deque &Q)
{
Q.front = Q.rear = 0;
return;
}
void EnQueue(Deque &Q, const BiTree &t)
{
Q.de_data[Q.rear++] = t;
}
void DeQueue(Deque &Q, BiTree &p)
{
if (Q.front != Q.rear)
p = Q.de_data[Q.front++];
}
bool IsEmptyQueue(Deque &Q)
{
return Q.front == Q.rear;
}
void LeveTraverse(BiTree &T)
{
BiTree p = T;
Deque Q;
InitDeque(Q);
// 首先将根结点入队
if (p != nullptr)
EnQueue(Q, p);
while (!IsEmptyQueue(Q))
{
// 依次出队,如果出队结点有子结点,入队
DeQueue(Q, p);
std::cout << p->data << std::endl;
if (p->lchild)
EnQueue(Q, p->lchild);
if (p->rchild)
EnQueue(Q, p->rchild);
}
}
5.二叉树(复制+深度+叶子结点树+结点总数)
#include <iostream>
#include <string>
// 二叉树链式存储结构
typedef struct BiTNode{
char data;
BiTNode *lchild, *rchild;
}*BiTree;
// 创建二叉树
void CreateBiTree(BiTree&);
// 先序遍历方法打印二叉树
void PreOrder(BiTree&);
// 复制二叉树
void Copy(BiTree&, BiTree&);
// 计算二叉树深度
int Depth(BiTree&);
// 计算结点总数
int NodeCount(BiTree&);
// 计算叶子结点个数
int LeafCount(BiTree&);
int main()
{
BiTree T;
CreateBiTree(T);
PreOrder(T);
// 复制二叉树
BiTree T1 = nullptr;
Copy(T, T1);
PreOrder(T1);
// 计算二叉树深度
std::cout << Depth(T) << std::endl;
// 计算结点总数
std::cout << NodeCount(T) << std::endl;
// 计算叶子结点个数
std::cout << LeafCount(T) << std::endl;
return 0;
}
void CreateBiTree(BiTree &T)
{
// 接受输入序列
char ch;
std::cin >> ch;
// 先序遍历方法创建二叉树
if (ch == '#')
T = nullptr;
else{
T = new BiTNode;
T->data = ch;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}
return;
}
void PreOrder(BiTree &T)
{
if (T == nullptr)
return;
std::cout << T->data << " ";
PreOrder(T->lchild);
PreOrder(T->rchild);
return;
}
void Copy(BiTree &T, BiTree &NewT)
{
if (T == nullptr)
NewT = nullptr;
else{
// 以根左右顺序进行复制
NewT = new BiTNode;
NewT->data = T->data;// 复制根结点
Copy(T->lchild, NewT->lchild);// 复制左子树(递归)
Copy(T->rchild, NewT->rchild);// 复制右子树
}
return;
}
int Depth(BiTree &T)
{
if (T == nullptr)
return 0;
else
{
int dep1 = Depth(T->lchild);// 计算左子树深度
int dep2 = Depth(T->rchild);// 计算右子树深度
return dep1 > dep2? dep1 + 1 : dep2 + 1;
}
}
int NodeCount(BiTree &T)
{
if (T == nullptr)
return 0;
else
return NodeCount(T->lchild) + NodeCount(T->rchild) + 1;//左子树结点个数+右子数结点个数+1
}
int LeafCount(BiTree &T)
{
if (T == nullptr)
return 0;
else if (!T->lchild && !T->rchild)
return 1;
return LeafCount(T->lchild) + LeafCount(T->rchild);//左子树叶子结点个数+右子数叶子结点个数
}