树

【1】树的基本概念

1： 树属于一种非线性数据结构

2： 树以分支关系描述数据元素之间的层次结构

3： 树(tree)是 n(n≥0) 个结点的有限集

4： 树的结构中，有且仅有一个特殊的结点，称为树的根结点(root)

5： 树中存在唯一的称为根的数据元素

6： 树中各子树是互不相交的集合

7： 树的根结点没有前驱结点，除根之外的所有结点都有且只有一个前驱结点

8： 树中所有的结点可以有0个或多个后继结点

9： 结点(node)——表示树中的数据元素

10： 结点的度(degree)——结点的子树个数

11： 树的度——树中结点的最大度值

12： 叶子(leaf)结点——度为0的结点

13： 分支结点——除叶子结点外的所有结点(度不为0)

14： 孩子(child)——结点的子树的根称为此结点的孩子

15： 双亲(parents)——此结点称为孩子的双亲

16： 兄弟(sibling)——具有同一双亲的孩子结点互称兄弟

17： 结点的层次(level)——从根结点算起，根为第一层，它的孩子为第二层等以此类推

18： 树的深度(depth)——树中结点的最大层次数

19： 有序树——树中各结点的子树看成从左到右是有次序的（即就是子树位置不可以互换）

20： 森林(forest)——m(m >= 0)棵互不相交的树的集合。

 将一棵非空树的根结点删去，树就变成一个森林；反之，给一个森林增加一个统一的根结点，森林就变成一棵树。

21： 二叉树是n(n>0)个结点的有限集，它或为空树(n=0)，或由一个根结点和两棵分别称为左子树和右子树的互不相交的二叉树构成

22： 树的高度：从结点x（某棵树的根结点）向下到某个叶结点最长简单路径中边的条数

备注：

对于整棵树而言，树的高度和深度是相等的。

而对于树中相同深度的每个结点来说，它们的高度却不一定相同。

【2】树的表示

【3】二叉树

（1）二叉树的定义

我们把满足以下两个条件的树形结构叫做二叉树（Binary Tree）： �    

1. 每个结点的度都不大于2； �    

2. 每个结点的孩子结点次序不能任意颠倒。  

由此定义可以看出：一个二叉树中的每个结点只能拥有0、1或2个孩子，而且每个孩子有左右之分。

而且我们把位于左边的孩子叫做左孩子，位于右边的孩子叫做右孩子。

（2）二叉树的五种基本形态

（3）二叉树的性质

（4）满二叉树和完全二叉树

在满二叉树中，每层结点都是满的，即每层结点都具有最大结点数的二叉树。

深度为k，结点数为n的二叉树，如果其结点1~n的位置序号分别与满二叉树的结点1~n的位置序号一一对应，则为完全二叉树。

满二叉树必为完全二叉树， 而完全二叉树不一定是满二叉树。

 

（5）完全二叉树的两个重要性质

（6）二叉树的存储结构

二叉树的结构是非线性的，每一结点最多可有两个后继。 �

二叉树的存储结构有两种： 顺序存储结构和链式存储结构。

1. 顺序存储结构

2. 链式存储结构

  二叉树的链式存储结构代码实现如下：

// BinTree实现代码
#include <iostream>
#include <fstream>
#include "Queue.h"
#include "Stack.h"
using namespace std;

template<class Type>
Type Max(const Type & a, const Type & b)
{
    return a > b ? a : b;
}

template<class Type>
class BinaryTree;

template<class Type>
class BinTreeNode
{
    friend class BinaryTree<Type>;
private:
    BinTreeNode<Type> *leftChild, *rightChild;
    Type data;

public:
    BinTreeNode():leftChild(NULL), rightChild(NULL)
    {}
    BinTreeNode(const Type &x, BinTreeNode<Type> *left = NULL, BinTreeNode<Type> *right = NULL)
        : data(x)
        , leftChild(left)
        , rightChild(right)
    {}
    ~BinTreeNode()
    {}

public:
    Type & GetData() 
    { 
        return data;
    }
    BinTreeNode<Type> *& GetLeft() 
    { 
        return leftChild;
    }
    void SetLeft(BinTreeNode<Type>* & pLeft) 
    { 
        leftChild = pLeft;
    }
    BinTreeNode<Type> *& GetRight() 
    { 
        return rightChild;
    }
    void SetRight(BinTreeNode<Type>* & pRight)
    {
        rightChild = pRight;
    }
    Type const & GetData() const 
    {
        return data;
    }
    BinTreeNode<Type> * const & GetLeft() const 
    {
        return leftChild;
    }
    BinTreeNode<Type> * const & GetRight() const 
    { 
        return rightChild;
    }
};

template<class Type>
class BinaryTree
{
private:
    BinTreeNode<Type> *root;
    Type RefValue;     
    //创建二叉树的两种方式：
    void CreateTree(BinTreeNode<Type> *&t)
    {
        Type item;
        cin >> item;
        if (item == RefValue)
        {
            t = NULL;
        }
        else
        {
            t = new BinTreeNode<Type>(item);
            CreateTree(t->leftChild);
            CreateTree(t->rightChild);
        }
    }
    void CreateTree(BinTreeNode<Type> *&t, istream &in)
    {
        Type item;
        in >> item;
        if (item == RefValue)
        {
            t = NULL;
        }
        else
        {
            t = new BinTreeNode<Type>(item);
            CreateTree(t->leftChild, in);
            CreateTree(t->rightChild, in);
        }
    }
    // 先序遍历
    void PreOrder(const BinTreeNode<Type> *t)const
    {
        if (t != NULL)
        {
            cout << t->data << " ";
            PreOrder(t->leftChild);
            PreOrder(t->rightChild);
        }
    }
    // 中序遍历
    void InOrder(const BinTreeNode<Type> *t) const
    {
        if (t != NULL)
        {
            InOrder(t->leftChild);
            cout << t->data << " ";
            InOrder(t->rightChild);
        }
    }
    // 后序遍历
    void PostOrder(const BinTreeNode<Type> *t) const
    {
        if (t != NULL)
        {
            PostOrder(t->leftChild);
            PostOrder(t->rightChild);
            cout << t->data << " ";
        }
    }
    // 大小
    int Size(BinTreeNode<Type> *t) const
    {
        return (NULL == t) ? 0 : 1 + Size(t->leftChild) + Size(t->rightChild); 
    }
    // 深度
    int Depth(BinTreeNode<Type> *t) const
    {
        return (NULL == t) ? 0 : 1 + Max(Depth(t->leftChild), Depth(t->rightChild));
    }
    // 摧毁二叉树
    void DestroyTree(BinTreeNode<Type> *t)
    {
        if (t != NULL)
        {
            DestroyTree(t->leftChild);
            DestroyTree(t->rightChild);
            delete t;
        }
    }
    // 拷贝
    BinTreeNode<Type>* Copy(const BinTreeNode<Type> *r) const
    {
        if (NULL == r)
        {
            return NULL;
        }
        else
        {
            BinTreeNode<Type> *s = new BinTreeNode<Type>(r->data);
            s->leftChild = Copy(r->leftChild);
            s->rightChild = Copy(r->rightChild);
            return s;
        }
    }
    // 查找某元素
    BinTreeNode<Type> * Find(BinTreeNode<Type> *cur, const Type &x) const
    {
        if (NULL == cur) 
        { 
            return NULL;
        }
        else
        {
            if (x == cur->data) 
                return cur;
            BinTreeNode<Type> *p = NULL;
            if ((p = Find(cur->leftChild, x)) != NULL)
                return p;
            else
                return Find(cur->rightChild, x);
        }
    }
    // 父亲节点
    BinTreeNode<Type> *Parent(BinTreeNode<Type> *start,
                              const BinTreeNode<Type> *current) const
    {
        if (NULL == start) 
        {
            return NULL;
        }
        else
        {
            if (start->leftChild == current || start->rightChild == current)
            {
                return start;
            }
            BinTreeNode<Type> *p = NULL;
            if ((p = Parent(start->leftChild, current)) != NULL)
                return p;
            else
                return Parent(start->rightChild, current);
        }
    }
    // 判相等
    bool Equal(const BinTreeNode<Type> *a, const BinTreeNode<Type> *b) const
    {
        if (NULL == a && NULL == b)
        {
            return true;
        }
        else if (NULL == a || NULL == b)
        {
            return false;
        }
        else 
        {
            if (a->data != b->data)
                return false;
            else
                return (Equal(a->leftChild, b->leftChild) &&
                        Equal(a->rightChild, b->rightChild));
        }
    }
    // 利用栈实现先序遍历
    void PreOrderByStack(BinTreeNode<Type>* p) const
    {
        SeqStack<const BinTreeNode<Type> *> sT;
        const BinTreeNode<Type> *s = NULL;
        if (p != NULL)
            sT.Push(p);
        while (!sT.IsEmpty())
        {
            sT.Pop(s);
            cout << s->data << " ";
            if (s->rightChild != NULL)
                sT.Push(s->rightChild);
            if (s->leftChild)
                sT.Push(s->leftChild);
        }
    }
    // 利用栈实现中序遍历
    void InOrderByStack(BinTreeNode<Type>* p) const
    {
        SeqStack<const BinTreeNode<Type> *> sT;
        const BinTreeNode<Type> *s = NULL;
        if (p != NULL)
            sT.Push(p);
        while (!sT.IsEmpty())
        {
            while (sT.GetTop(s) && s != NULL)
            {
                sT.Push(s->leftChild);
            }
            sT.Pop(s); //空值退栈
            if (!sT.IsEmpty())
            {
                sT.Pop(s);
                cout << s->data << " ";
                sT.Push(s->rightChild);
            }
        }
    }
    // 利用栈实现后序遍历（有标记位）
    void PostOrderByStackFlag(const BinTreeNode<Type>* p) const
    {
        SeqStack<const BinTreeNode<Type> *> sT;
        const BinTreeNode<Type> *s = NULL;
        do
        {
            while (p != NULL)  
            { 
                sT.Push(p); 
                p = p->leftChild;
            }
            s = NULL;
            while (!sT.IsEmpty())
            {  
                sT.GetTop(p);
                if (p->rightChild == s)  //t:表示为null 或者 右子节点被访问过了。  
                {  
                    cout << p->data << " ";
                    sT.Pop(p);
                    s = p;  //记录下刚刚访问的节点  
                }
                else 
                {  
                    p = p->rightChild;  
                    break;
                }
            }
        } while (!sT.IsEmpty());
    }
    // 利用栈实现后序遍历（无标记位）
    void PostOrderByStack(const BinTreeNode<Type>* p) const
    {
        SeqStack<const BinTreeNode<Type> *> sT;
        if (NULL == p)
            return;
        while (1)
        {
            while (p)
            {
                sT.Push(p);
                p = p->leftChild;
            }
            sT.GetTop(p);
            while (NULL == p)
            {
                sT.Pop(p);
                sT.Pop(p);
                cout << p->data << " ";
                if (sT.IsEmpty())
                    return;
                sT.GetTop(p);
            }
            sT.Push(NULL);
            p = p->rightChild;
        }
    }
    // 利用队列实现层次遍历
    void LevelOrder(BinTreeNode<Type> * p)
    {
        SeqQueue<const BinTreeNode<Type> *>   sQ;
        const BinTreeNode<Type> *s = NULL;
        if (p != NULL)
            sQ.EnQueue(p);
        while (!sQ.IsEmpty())
        {
            sQ.DeQueue(s);
            cout << s->data << " ";
            if (s->leftChild != NULL)
            {
                sQ.EnQueue(s->leftChild);
            }
            if (s->rightChild != NULL)
            {
                sQ.EnQueue(s->rightChild);
            }
        }
        cout << endl;
    }
public:
    BinaryTree():root(NULL)
    {}
    BinaryTree(Type x):RefValue(x), root(NULL)
    {}
    BinaryTree(BinaryTree<Type> &bt):RefValue(bt.RefValue)
    {
        root = bt.Copy();
    }

    BinaryTree<Type> & operator=(const BinaryTree<Type> &bt)
    {
        if (this != &bt)
        {
            DestroyTree(root);
            root = bt.Copy(bt.root);
        }
        return *this;
    }

    ~BinaryTree()
    {
        DestroyTree(root);
        root = NULL;
    }
public:
    BinTreeNode<Type> * GetRoot() 
    { 
        return root;
    }

    BinTreeNode<Type> * Copy()
    {
        return Copy(root);
    }

    void CreateTree()
    {
        CreateTree(root);
    }

    void CreateTree(istream &in)
    {
        CreateTree(root, in);
    }

    void PreOrder() const
    {
        PreOrder(root);
        cout << endl;
    }

    void InOrder() const
    {
        InOrder(root);
        cout << endl;
    }

    void PostOrder() const
    {
        PostOrder(root);
        cout << endl;
    }

    void PreStack() const
    {
        PreOrderByStack(root);
        cout << endl;
    }

    void InStack() const
    {
        InOrderByStack(root);
        cout << endl;
    }

    void PostStack() const
    {
        PostOrderByStack(root);
        cout << endl;
    }

    void PostStackFlag() const
    {
        PostOrderByStackFlag(root);
        cout << endl;
    }

    void LevelOrder()
    {
        LevelOrder(root);
    }
    // 所有遍历方式：
    void Traverse()
    {
        cout << "先序遍历:";
        PreOrder();
        cout << "中序遍历:";
        InOrder();
        cout << "后序遍历:";
        PostOrder();
        cout << "利用队列层次遍历:";
        LevelOrder();
        cout << "利用栈先序遍历:";
        PreStack();
        cout << "利用栈中序遍历:";  
        InStack();
        cout << "利用栈后序遍历（有标记位）:";
        PostStackFlag();
        cout << "利用栈后序遍历（无标记位）:";
        PostStack();
    }

    int Size() const
    {
        return Size(root);
    }

    int Depth() const
    {
        return Depth(root);
    }

    void DestroyTree()
    {
        DestroyTree(root);
        root = NULL;
    }
    // 插入元素
    bool Insert(const Type& item)
    {
        BinTreeNode<Type> *newnode = new BinTreeNode<Type>(item);
        if (NULL == root)
        {
            root = newnode;
            return true;
        }

        BinTreeNode<Type> *pItem = Find(item);
        if (pItem != NULL)
        {
            cout << "The item " << item << " is exist!" <<endl;
            return false;
        }
        
        BinTreeNode<Type> *pstart = root;
        while (1)
        {
            if (item < pstart->data)
            {
                if (NULL == pstart->leftChild)
                {
                    pstart->leftChild = newnode;
                    return true;
                }
                pstart = pstart->leftChild;    
            }
            else
            {
                if (NULL == pstart->rightChild)
                {
                    pstart->leftChild = newnode;
                    return true;
                }
                pstart = pstart->rightChild;
            }
        }
    }

    BinTreeNode<Type> * Parent(const BinTreeNode<Type> *current)const
    {
        return (NULL == root || root == current) ? NULL : Parent(root, current);
    }

    BinTreeNode<Type> *LeftChild(BinTreeNode<Type> *current)const
    {
        return current->leftChild;
    }

    BinTreeNode<Type> *RightChild(BinTreeNode<Type> *current) const
    {
        return current->rightChild;
    }

    BinTreeNode<Type> *Find(const Type &x) const
    {
        return NULL == root ? NULL : Find(root, x);
    }

    bool Equal(const BinaryTree<Type> & bt) const
    {
        return Equal(root, bt.root);
    }

    friend bool operator==(const BinaryTree<Type> &bt1, const BinaryTree<Type> &bt2);

    template<class Type>
    friend istream & operator>>(istream &in, BinaryTree<Type> &bt);
    template<class Type>
    friend ostream & operator<<(ostream &out, const BinaryTree<Type> &bt);
};

template<class Type>
istream & operator>>(istream &in, BinaryTree<Type> &bt)
{
    bt.CreateTree(in);
    return in;
}

template<class Type>
ostream & operator<<(ostream &out, const BinaryTree<Type> &bt)
{
    bt.InOrder();    //按中序输出
    return out;
}

template<class Type>
bool operator ==(const BinaryTree<Type> &bt1, const BinaryTree<Type> &bt2)
{
    return bt1.Equal(bt2);
}
//////////////////////////////////////////////////
void main()
{
    BinaryTree<char> mytree('#');
    ifstream ifile("Test.txt", ios::in);
    if (!ifile)
        return;
    // 创建二叉树
    ifile >> mytree;
    // 输出二叉树
    cout << "重载输出操作符，输出二叉树："<< mytree;

    BinTreeNode<char> *s = mytree.Find('E');
    cout << "查找节点E: " << s->GetData() << endl;
    BinTreeNode<char> *p = mytree.Parent(s);
    cout << "查找节点E的父节点：" << p->GetData() << endl;
    
    cout << "所有遍历二叉树方式及其结果如下：" << endl;
    mytree.Traverse();
    
    cout << "二叉树的节点数：" << mytree.Size() << endl;
    cout << "二叉树的深度：" << mytree.Depth() << endl;

    cout << "拷贝构造函数重新构建新的二叉树youtree" << endl;
    BinaryTree<char>   youtree(mytree);
    cout << "youtree 与 mytree  相等 ? " << youtree.Equal(mytree) << endl;
    // 测试插入函数
    if (mytree.Insert('I'))
    {
        cout << "插入成功后再遍历二叉树：" << endl;
        mytree.Traverse();
    }
}

以上代码中引用的queue.h文件和stack.h文件可以从《队列》 和 《栈》两篇随笔中拷贝即可。

（7）二叉树的遍历和创建二叉树

1. 二叉树的遍历

假使用L、D、R分别表示遍历左子树、访问根结点、遍历右子树

那么对二叉树的遍历顺序就可以有六种方式： �

a. 访问根，遍历左子树，遍历右子树（记做DLR）

b. 访问根，遍历右子树，遍历左子树（记做DRL）

c. 遍历左子树，访问根，遍历右子树（记做LDR）

d. 遍历左子树，遍历右子树，访问根（记做LRD）

e. 遍历右子树，访问根，遍历左子树（记做RDL）

f. 遍历右子树，遍历左子树，访问根（记做RLD）

二叉树的遍历常用为三种：先序，中序，后序

先序遍历（DLR）即就是先根遍历

中序遍历（LDR）即就是中根遍历

后序遍历（LRD）即就是后根遍历

三种遍历示例如下：

2. 创建二叉树

a. 由先序序列创建二叉树

b. 先序和中序创建二叉树

c. 中序和后序创建二叉树

三种创建二叉树方式实现代码如下：

#include <stdio.h>
#include <malloc.h>

typedef char TElemType;

typedef struct BiTNode
{
    struct BiTNode *leftChild, *rightChild;
    TElemType data;
} BiTNode, *BiTree;

//初始化
void InitTree(BiTree &t)
{
    t = NULL;
}
// 先序遍历
void PreOrder(BiTree &t)
{
    if (t != NULL)
    {
        printf("%c ", t->data);
        PreOrder(t->leftChild);
        PreOrder(t->rightChild);
    }
}
// 中序遍历
void InOrder(BiTree &t)
{
    if (t != NULL)
    {
        InOrder(t->leftChild);
        printf("%c ", t->data);
        InOrder(t->rightChild);
    }
}
// 后序遍历
void PostOrder(BiTree t)
{
    if (t != NULL)
    {
        PostOrder(t->leftChild);
        PostOrder(t->rightChild);
        printf("%c ", t->data);
    }
}
// 由先序和中序创建二叉树
void  Pre_In_Create(char *pre, char *in, int len, BiTree &t)
{
    if (len <= 0) return;
    char *p = NULL, *q = NULL;
    int i = 0;
    t = (BiTree)malloc(sizeof(BiTNode));
    t->data = pre[0];    // 根节点
    t->leftChild = NULL;
    t->rightChild = NULL;
    while (i < len)
    {
        if (*(in + i) == pre[0])
            break;
        ++i;
    }
    p = pre + 1;      // 左子树的先序序列
    q = in;
    Pre_In_Create(p, q, i, t->leftChild);
    p = pre + i + 1;  // 右子树的先序序列
    q = in + i + 1;
    Pre_In_Create(p, q, len-i-1, t->rightChild);
}
// 由中序后序创建二叉树
void  In_Pos_Create(char *in, char *pos, int len, BiTree &t)
{
    if (len <= 0) return;
    char *p = NULL, *q = NULL;
    int i = 0;                // i 表示根节点在中序中的位置
    t = (BiTree)malloc(sizeof(BiTNode));
    t->data = pos[len-1];     // 确定根节点
    t->leftChild = NULL;
    t->rightChild = NULL;
    while (i < len)
    {
        if (*(in + i) == pos[len-1])
            break;
        ++i;
    }
    p = in;                
    q = pos;
    In_Pos_Create(p, q, i, t->leftChild);
    p = in + i + 1;           
    q = pos + i;
    In_Pos_Create(p, q, len-i-1, t->rightChild);
}
// 由先序序列创建二叉树
void CreatePre(BiTree &t, TElemType *&str)
{
    if (*str == '#')
    {
        t = NULL;
    }
    else
    {
        t = (BiTNode *)malloc(sizeof(BiTNode));
        t->data = *str;
        CreatePre(t->leftChild, ++str);
        CreatePre(t->rightChild, ++str);
    }
}

void PrintAll(BiTree& t)
{
    PreOrder(t);
    printf("
");
    InOrder(t);
    printf("
");
    PostOrder(t);
    printf("
");
}

void main()
{
    printf("由先序序列创建二叉树mytree: 
");
    TElemType *buff = "ABC##DE##F##G#H##";
    BiTree mytree;
    InitTree(mytree);
    CreatePre(mytree, buff);
    printf("Print  mytree: 
");
    PrintAll(mytree);

    char *pbuff = "ABCDEFGH";
    char *ibuff = "CBEDFAGH";
    char *tbuff = "CEFDBHGA";
    BiTree  mypretree;
    InitTree(mypretree);
    printf("由先序和中序创建二叉树mypretree: 
");
    Pre_In_Create(pbuff, ibuff, 8, mypretree);
    printf("Print  mypretree: 
");
    PrintAll(mypretree);

    BiTree  mypostree;
    InitTree(mypostree);
    printf("由中序和后序创建二叉树mypostree: 
");
    In_Pos_Create(ibuff, tbuff, 8, mypostree);
    printf("Print  mypostree: 
");
    PrintAll(mypostree);
}

（8）线索二叉树

1. 为什么要线索化二叉树？

遍历二叉树除了设栈，要么就用递归进行。有没有其它更好的方式呢？

遍历二叉树实质上是对一个非线性结构进行线性化操作的过程。

那么既然是线性化的过程能否先像线性链表那样把树结构进行线性化？

当以二叉链表作为存储结构时，只能找到结点的左右孩子信息，并不能找到结点在任一序列中的前驱和后继信息。

所以为了方便于遍历，只有通过在每个结点上增加两个指针域，分别指示结点在任一次序遍历时得到的前驱和后继。

指向结点的前驱和后继的指针叫做线索。

加上线索的二叉树称为线索二叉树。

对二叉树以某种次序（先序，中序，后序）遍历使其变为线索二叉树的过程叫做线索化。

所谓穿线二叉树，即在一般二叉树的基础上，对每个结点进行考察：

若其左子树非空，则其左指针不变，仍指向左子女；

若其左子树为空，则让其左指针指向某种遍历顺序下该结点的前驱；

若其右子树非空，则其右指针不变，仍指向右子女；

若其右子树为空，则让其右指针指向某种遍历顺序下该结点的后继。

线索化二叉树其实通俗点说：就好像要从某个地方要到另一个地方去，以前咱是边走边找路。

而现在是根据以前“经验”（某种次序）在路上做好标记，以后你不管走多少次，只要按照标线走就行，不需要再每次都边走边找路了。

线索化的过程需要用到遍历算法，一旦线索建立后，在此结构上遍历就可以不用递归、也不用栈了，实现更加容易

总而言之：

线索化二叉树相当于是按照某种遍历的次序，提前把遍历的路径给做好标记，以后再遍历的时候就会方便很多，所以要线索化二叉树。

线索二叉树的图示：

切记：

 有n个节点的二叉链表中必定存在n+1个空链域

 在一棵有n个节点度为k的树中必有n(k-1)+1个空链域

【4】树和森林

（1）树的存储结构

1. 双亲表示法

由于树中的每个结点都有唯一的一个双亲结点，所以可用一组连续的存储空间（一维数组）存储树中的各个结点。

数组中的一个元素表示树中的一个结点，每个结点含两个域，数据域存放结点本身信息，双亲域指示本结点的双亲结点在数组中位置。

2. 孩子表示法

孩子表示法又分为 多重链表法 和 孩子链表表示法。

a. 多重链表法 指每个结点包括一个结点信息域和多个指针域，每个指针域指向该结点的一个孩子结点，通过各个指针域值反映出树中各结点之间的逻辑关系。

在这种表示法中，树中每个结点有多个指针域，从而形成了多条链表。

由于每个结点的孩子个数没有限制，各结点的度数又各异，所以操作不容易实现，可能会造成存储空间的浪费。

b. 孩子链表法与双亲表示法相反，便于查找树中某结点的孩子，由某结点的指针域便可实现，它的主体是一个与结点个数一样大小的一维数组。

数组的每一个元素由两个域组成，一个域用来存放结点信息，另一个用来存放指针，该指针指向由该结点孩子组成的单链表的首位置。

单链表的结构也由两个域组成，一个存放孩子结点在一维数组中的序号，另一个是指针域，指向下一个孩子。

孩子表示法方便了有关孩子的操作，但有时为了便于找到双亲，可以将双亲表示法和孩子表示法相结合：

即增加一个域，存储该结点双亲结点在数组中的序号。这种存储结构称为代双亲的孩子链表。

3. 左孩子右兄弟表示法

孩子兄弟表示法又称二叉树表示法，这是一种常用的存储结构。

它用二叉链表作为树的存储结构，链表中每个结点的两个指针域分别指向其第一个孩子结点和下一个兄弟结点。

（2） 树与二叉树的对应关系

（3） 森林与二叉树的对应关系

（4） 二叉树转换为树

（5） 树转换为二叉树

（6） 二叉树转换为森林

（7） 森林转换为二叉树

【5】霍夫曼树

关于霍夫曼树请参见随笔《赫夫曼树》