二叉树 概念+代码

 树

---

空树和非空树

树是一个递归的定义，根结点除外剩余的部分都可以看作为一棵树。

子树之间是互不相交的

内部节点：除了树根和子叶节点

树根是第一层（不统一，不同书的描述不同。）

树的存储

• 顺序存储

1. 双亲表示法           优点：找双亲方便                缺点：找孩子不容易
2. 孩子表示法           优点：找孩子方便                缺点：树的节点最大度 为开辟的空间，很浪费空间。  找双亲不方便
3. 双亲孩子表示法     优点：找孩子和双亲方便       缺点：耗费空间

• 链式存储

1. 孩子链表表示法      把孩子放在头节点后面  类似于链式前向星表示
2. 孩子兄弟表示法      左指针长子 右指针兄弟        根据孩子兄弟表示法把任何树都可以转化为二叉树（相互转化）

 森林把每颗树树根看成兄弟

二叉树 

---

用处比较多

每一层是上一层的2倍

任何一颗二叉树，叶子节点数为n0，度数为2的节点为n2，n0=n2+1

n=n0+n1+n2总节点数，节点数等于分支数加一；n=1*n1+2*n2+1;

1*n1+2*n2+1 = n0+n1+n2  故，得到n0=n2+1

二叉树存储

• 顺序存储：

1. 补零补成完全二叉树，然后句可以按顺序存储。        缺点   补零可能太多。
2. 完全二叉树  可以 顺序存储
3. 用 l[]数组 和 r[]数组    必须指明根root节点   经常用

• 链式存储：

1. lchild  data  rchild 

二叉树遍历

先序遍历：根左右         递归

中序遍历：左根右         递归

后序遍历：左右根         递归

层次遍历：一层一层访问（同一层从左向右）     方法：队列         出队的同时孩子进去

已知先序和中序、后序和中序要得到另外一个序列其实拆解都是中序序列。

空就结束，不操作。

题目一：补空创建二叉树

输入：补空序列 创建二叉树

#include <iostream>
#include <queue>

using namespace std;

// 定义二叉树存储结构
struct Bonde{
    char data;
    struct Bonde *lchild, *rchild;
};
typedef struct Bonde *Btree;
typedef struct Bonde Bonde;  // 给看结构体起的别名

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

int Depth(Btree T){  // 求二叉树的深度
    int m, n;
    if(T == NULL)  // 如果为空树，c深度为0
        return 0;
    else{
        m = Depth(T->lchild);  // 递归计算左子树深度
        n = Depth(T->rchild);  // 递归计算右子树深度
        if(m>n)
            return m+1;  // 返回左右子树最大值加1
        else
            return n+1;
    }
}

int main(){
    Btree mytree;
    cout << "按先序次序输入二叉树中国结点的值（孩子为空是输入#），创建一颗二叉树" << endl;
    // ABD##E##CF#G###
    Createtree(mytree);  // 创建二叉树
    cout << endl;
    cout << "二叉树的深度为：" << Depth(mytree) << endl;
    return 0;
}

ABD##E##CF#G###
按先序次序输入二叉树中国结点的值（孩子为空是输入#），创建一颗二叉树

二叉树的深度为：4
Program ended with exit code: 0

　

 题目二：二叉树遍历     前序、中序、后序、层次遍历

#include <iostream>
#include <queue>
using namespace std;

struct Bonde{
    char data;
    struct Bonde *lchild, *rchild;
};

typedef struct Bonde Bonde;
typedef struct Bonde *Btree;

void Createtree(Btree &T){
    char ch;
    cin >> ch;
    if(ch == '#')
        T = NULL;
    else{
        T = new Bonde;
        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;
}

按先序层次输入二叉树中结点的值（孩子为空时输入#），创建一颗二叉树
ABD##E##CF#G###

二叉树的先序遍历结果：
A B D E C F G 
二叉树的中序遍历结果：
D B E A F G C 
二叉树的后序遍历结果：
D E B G F C A 
二叉树的层次遍历结果：
A B C D E F G 
Program ended with exit code: 0

 题目三：二叉树还原  先序和中序得二叉树     后序和中序得二叉树

思路：

1. 先序找根
2. 中序分左右

 函数（先序序列开始位置， 中序序列开始位置， 序列长度）

#include <iostream>
using namespace std;

typedef struct node{
    char data;
    struct node *lchild, *rchild;
}BiTNode, *BiTree;

// 也就是说BitNode是struct的别名，BiTree是struct的指针，指针只是指向地址对象的，不能用来创建对象，而BitNode是可以用来创建对象实体的

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 0;
    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;
    }
}
/*
 7
 A B D E C F G
 D B E A F G C
 D E B G F C A
 */
int main(){
    BiTree T;
    int n;
    char pre[100], mid[100], last[100];
    cout << "1.前序中序还原二叉树
";
    cout << "2.后序中序b还原二叉树
";
    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;
}

1.前序中序还原二叉树
2.后序中序b还原二叉树
请选择：1
请输入节点的个数：
7
请输入前序序列：
 A B D E C F G
请输入中序序列：
D B E A F G C

二叉树还原成功，输出其后序序列：
DEBGFCA

 题目四：二叉树的  叶子数  结点数

#include <iostream>
using namespace std;

typedef struct Bnode{
    char data;
    struct Bnode *lchild, * rchild;
}Bnode, *Btree;

void Createtree(Btree &T){  // 引用传递 需要对T的进行修改的时候使用Btree &T， 不需要修改时候使用Btree T
    char ch;
    cin >> ch;
    if(ch == '#')
        T = NULL;
    else
    {
        T = new Bnode;
        T->data = ch;
        Createtree(T->lchild);
        Createtree(T->rchild);
    }
}

int NodeCount(Btree T){
    // 求二叉树的结点个数
    if(T == NULL)
        return 0;
    else
        return NodeCount(T->lchild)+NodeCount(T->rchild)+1;  // 递归计算左右子树结点数之和
}

int LeafCount(Btree T){
    if(T == NULL)
        return 0;
    else
        if(T->lchild==NULL && T->rchild==NULL)  // 左右子树均为空为子叶节点，则叶子数为1
            return 1;
        else
            return LeafCount(T->lchild)+LeafCount(T->rchild); // 递归计算左右子树叶子节点之和
}

int main(){
    Btree mytree;
    cout << "按先序输入二叉树结点的值（孩子为空时输入#），创建一颗二叉树" << endl;
    // AB##E##CF#G###
    Createtree(mytree);
    cout << endl;
    cout << "二叉树结点是为：" << NodeCount(mytree) << endl;
    cout << "二叉树叶子数为：" << LeafCount(mytree) << endl;
    return 0;
}