4、二叉树创建

目录

1. 二叉树的顺序存储结构

 2.二叉树的链式存储

 3.二叉树先序建立（先序遍历+中序遍历+后序遍历）

4.二叉树的层次遍历

5.二叉树（复制+深度+叶子结点树+结点总数）

---

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);//左子树叶子结点个数+右子数叶子结点个数
}