二叉树的基本操作

一、树：

树 ：一种非线性数据结构

树的应用：

• 操作系统中：用树表示文件目录组织结构

• 编译系统中: 用树表示源程序语法结构

相关概念常见表示方法：

• 树有且仅有一个根节点

• 树的结构定义是一个递归的定义

• 树可以看做一个集合，每个集合下面又有很多子集合，所以单节点与子树之间可以表示为 T={跟结点，左孩子，右孩子}

  -实例：T1 ={A,B,C}

• 当然，树还可以用括号表示，这样更加容易看

  • 上图可表示为：(A (B(D,E(G) ), C( F(H,J) ) )

• 还可以通过图形来表示：

---

基本树语：

1. 结点的度：拥有的子树（也就是说有几个分支）
2. 树的度：树中结点度的最大值
3. 叶子结点（终端结点）：度为0的结点（没有分支）
4. 双亲和孩子：如下图：A是B、C的双亲，B、C是A的孩子。
5. 堂兄弟：如下图：双亲在同一层（如E和F）
6. 高度（深度）：书中结点最大几层（比如下图为深度：3）
   

---

二、二叉树：

二叉树：树的度为2的二叉树（结点最大度为2）。

性质：

• 第i层最多 2^(i-1)个结点
• 深度为k，最多2^k - 1 个结点
• 叶子结点树为n,度为2的节点数为n2，那么n=n2+1
• n个结点的二叉树深度：log2n + 1 (log2n不小于log2n的整数)

满二叉树与完全二叉树：

1、满二叉树：
深度为k且含有2^k-1个结点。看图很容易理解。

2、完全二叉树：
每个结点都与所对应的完全二叉树一 一对应，叶子几点只可能出现在最后两层。

二叉树的三种遍历算法：

1、前序遍历：ABDGHCEIF（规则是先是根结点，再前序遍历左子树，再前序遍历右子树）

2、中序遍历：GDHBAEICF（规则是先中序遍历左子树，再是根结点，再是中序遍历右子树）

3、后序遍历：GHDBIEFCA（规则是先后序遍历左子树，再是后序遍历右子树，再是根结点）

---

三、C语言实现基本操作（三种遍历算法）;

1、定义树的结构体：

typedef struct BTree{    char data;                  struct BTree *lChild;  //左孩子    struct BTree *rChild;  //右孩子}BinTree;

---

2、创建树：

输入顺序是先遍历根结点，再遍历左右结点，也就是先序遍历，然后重复把左右孩子当做根节点，重复上诉过程，这就是一个递归过程。这里用“#”表示孩子为空，所以下图中B就表示叶子结点，而C没有左孩子。

这里要求要通过先序遍历输入各结点，如果要创建这个树应该输入：AB##C#D##

BinTree *CreateTree(BinTree *p){    char ch;    scanf("%c",&ch);    if (ch == '#')      {        return NULL;       }    p=(BinTree *)malloc(sizeof(BinTree));    p->data = ch;    p->lChild = CreateTree(p->lChild);  //递归左孩子    p->rChild = CreateTree(p->rChild);  //递归又孩子    return p;}

这里有碰到个问题，才发现自己对scanf还是没理解深刻。明明我只输入了（一次性输入了所有字符），char型的ch一次也只能接收一个字符，那么为什么可以实现二叉树的创建呢？

原来scanf输入是把所有的字符都存入了缓冲区，每调用一次scanf就从缓冲区读入一个字符，如果读到回车，scanf就结束。

通过一个程序验证一下：

#include <stdio.h>int main(){    char a;    char b;    char c;    printf("input a:\n");    scanf("%c",&a);  //如果这里输入abc，则接下来的scanf会分别读取b , c    //getchar();      printf("input b:\n");    scanf("%c",&b);    printf("input c:\n");    scanf("%c",&c);    printf("%c",a);    printf("%c",c);    return 0;}

---

3、前序遍历：

根结点->左孩子->右孩子

void PreOrder(BinTree *T){    if(T)    {        printf("%c",T->data);  //先打印数据，也就是遍历根节点        PreOrder(T->lChild);        PreOrder(T->rChild);    }}

---

4、中序遍历

左孩子->根结点->右孩子

void MidOrder(BinTree *T){    if (T)    {        MidOrder(T->lChild);        printf("%c",T->data);        MidOrder(T->rChild);    }}

---

4、后序遍历：

左孩子->右孩子->根结点

void LastOrder(BinTree *T){    if(T)    {        LastOrder(T->lChild);        LastOrder(T->rChild);        printf("%c",T->data);    }}

5、复制二叉树;

void Copy(BinTree *T,BinTree **newTree)  //二级指针存放指针的地址{    if(T == NULL)    {        *newTree = NULL;        return ;    }    else    {        *newTree = (BinTree *)malloc(sizeof(BinTree));        (*newTree)->data = T->data;        Copy(T->lChild,&(*newTree)->lChild);         //注意带*号变量指向成员时要加括号        Copy(T->rChild,&(*newTree)->rChild); //注意第二个参数穿的是地址，所以需要在前面加取地址符号 &      }}

这里用了二级指针存放了指针地址，如果不用二级指针，则需要用返回值的形式来返回新树的地址。如下：程序改为了：

BinTree *Copy(BinTree *T)  //只需要传入T即可，直接返回一个新的地址{    if(T == NULL)    {        newTree = NULL;        return newTree;    }    else    {        newTree = (BinTree *)malloc(sizeof(BinTree));        newTree->data = T->data;        newTree->lChild=Copy(T->lChild);        newTree->rChild=Copy(T->rChild);    }    return newTree;}

6、其他操作：

int Sumleaf(BinTree *T)   //求叶结点总数{    int sum=0,m,n;    if (T)    {        if ((!T->lChild) && (!T->rChild))        {            sum++;        }        m=Sumleaf(T->lChild);        sum+=m;        n=Sumleaf(T->rChild);        sum+=n;    }    return sum;}int Depth(BinTree *T)  //树的深度{    int dep=0,dep1,depr;    if (!T)    {        dep=0;    }    else   //分别对左右孩子遍历，看谁的层数大就取谁的值    {        dep1=Depth(T->lChild);        depr=Depth(T->rChild);        dep=1+(dep1>depr ? dep1:depr);    }    return dep;}

总结：

1、递归的时候一定要注意参数传入：

在这个过程中，遇到最大问题就是在复制二叉树那段代码。因为对二级指针操作不是太熟练，所以递归的时候开始的时候老是提示错误：

expected ‘struct BinTree **’ but argument is of type ‘struct BTree *’

后来不断检查才知道，因为二级指针要传的是地址，第一次传了地址，但是第二次没有加取地址符。

2、注意带 * 号变量指向问题：

带*号变量应该正确的指向方法应该是：（*p)->a 而不应该是*p->a

---

完整代码：

#include <stdio.h>#include <stdlib.h>  //for malloc typedef struct BTree{    char data;    struct BTree *lChild;    struct BTree *rChild;}BinTree;BinTree *CreateTree(BinTree *p){    char ch;    scanf("%c",&ch);    if (ch == '#')  //# standard for the leaf node    {        return NULL;       }    p=(BinTree *)malloc(sizeof(BinTree));    p->data = ch;    p->lChild = CreateTree(p->lChild);    p->rChild = CreateTree(p->rChild);    return p;}int Sumleaf(BinTree *T){    int sum=0,m,n;    if (T)    {        if ((!T->lChild) && (!T->rChild))        {            sum++;        }        m=Sumleaf(T->lChild);        sum+=m;        n=Sumleaf(T->rChild);        sum+=n;    }    return sum;}int Depth(BinTree *T){    int dep=0,dep1,depr;    if (!T)    {        dep=0;    }    else    {        dep1=Depth(T->lChild);        depr=Depth(T->rChild);        dep=1+(dep1>depr ? dep1:depr);    }    return dep;}void PreOrder(BinTree *T){    if(T)    {        printf("%c",T->data);        PreOrder(T->lChild);        PreOrder(T->rChild);    }}void MidOrder(BinTree *T){    if (T)    {        MidOrder(T->lChild);        printf("%c",T->data);        MidOrder(T->rChild);    }}void LastOrder(BinTree *T){    if(T)    {        LastOrder(T->lChild);        LastOrder(T->rChild);        printf("%c",T->data);    }}void Copy(BinTree *T,BinTree **newTree) {    if(T == NULL)    {        *newTree = NULL;        return ;    }    else    {        *newTree = (BinTree *)malloc(sizeof(BinTree));        (*newTree)->data = T->data;        Copy(T->lChild,&(*newTree)->lChild);        Copy(T->rChild,&(*newTree)->rChild);    }}int main(){    BinTree *Tree;    BinTree *newtree;    printf("请以前序遍历的方式输入扩展二叉树，用“#”表示空结点：\n");    Tree=CreateTree(Tree);    printf("前序遍历:\n");    PreOrder(Tree);    printf("\n中序遍历:\n");    MidOrder(Tree);    printf("\n后序遍历:\n");    LastOrder(Tree);    printf("\n叶结点总数：%d\n",Sumleaf(Tree));    printf("\n树的层数：%d\n",Depth(Tree));    Copy(Tree,&newtree);    //如果Copy()函数是返回值的形式调用应该如此：    //newtree=Copy(Tree);    printf("\n复制树后序遍历:\n");    LastOrder(newtree);  //用来检验是否成功    return 0;}

---

测试：
要创建如下二叉树，并且输出：先/中/后序遍历结果

输入（先序遍历输入）：AB##C#D##
测试结果：

本文参考：http://www.cnblogs.com/liuamin/p/6269950.html