【C 数据结构-树】3. 普通树

• 前面学了二叉树的存储结构，本节学习如何存储具有普通树结构的数据。例如下图所示为普通树存储结构。
  

• 通常，存储具有普通树结构数据的方法有 3 种：

  • 双亲表示法；
  • 孩子表示法；
  • 孩子兄弟表示法；

【 1. 树的双亲表示法 】

• 双亲表示法 采用 顺序表（也就是数组）存储普通树。其实现的核心思想是： 顺序存储各个节点的同时，给各节点附加一个记录其父节点位置的变量。而根节点没有父节点（父节点又称为双亲节点），因此 根节点记录父节点位置的变量通常置为 -1。
• 双亲表示法适用于查找某个节点的父节点。

• 例如，采用双亲表示法存储上图中普通树，其存储状态如下图 所示：
  

• 存储普通树的过程转化为 C 语言代码为：

#define MAX_SIZE 100	//宏定义树中结点的最大数量
typedef char ElemType;	//宏定义树结构中数据类型
typedef struct Snode
{
    TElemType data;		//树中结点的数据类型
    int parent;			//结点的父结点在数组中的位置下标
}PTNode;

typedef struct
{
    PTNode tnode[MAX_SIZE];	//存放树中所有结点
    int n;					//根的位置下标和结点数
}PTree;

• 存储上面普通树的 C 实现为：

#define _CRT_SECURE_NO_WARNINGS 1
#define MAX_SIZE 20
#include<stdio.h>
#include<stdlib.h>
typedef char ElemType;//宏定义树结构中数据类型
typedef struct Snode  //结点结构
{
    ElemType data;
    int parent;
}PNode;
typedef struct  //树结构
{
    PNode tnode[MAX_SIZE];
    int n;                 //结点个数
}PTree;

PTree InitPNode(PTree tree)
{
    int i, j;
    char ch;
    printf("请输出节点个数:\n");
    scanf("%d", &(tree.n));
    printf("请输入结点的值其双亲位于数组中的位置下标:\n");
    for (i = 0; i < tree.n; i++)
    {
        getchar();
        scanf("%c %d", &ch, &j);
        tree.tnode[i].data = ch;
        tree.tnode[i].parent = j;
    }
    return tree;
}
void FindParent(PTree tree)
{
    char a;
    int isfind = 0;
    printf("请输入要查询的结点值:\n");
    getchar();
    scanf("%c", &a);
    for (int i = 0; i < tree.n; i++) {
        if (tree.tnode[i].data == a) {
            isfind = 1;
            int ad = tree.tnode[i].parent;
            printf("%c的父节点为 %c,存储位置下标为 %d", a, tree.tnode[ad].data, ad);
            break;
        }
    }
    if (isfind == 0) {
        printf("树中无此节点");
    }
}

int main()
{
    PTree tree;
    for (int i = 0; i < MAX_SIZE; i++) {
        tree.tnode[i].data = ' ';
        tree.tnode[i].parent = 0;
    }

    tree = InitPNode(tree);
    FindParent(tree);
    return 0;
}

【 2. 树的孩子表示法 】

• 孩子表示法 存储普通树采用的是 顺序表+链表 的组合结构，存储过程是：从树的根节点开始，使用顺序表依次存储树中各个节点，需要注意的是，与双亲表示法不同，孩子表示法会给各个节点配备一个链表，用于存储各节点的孩子节点位于顺序表中的位置。如果节点没有孩子节点（叶子节点），则该节点的链表为空链表。
• 使用孩子表示法存储的树结构，正好和双亲表示法相反， 适用于查找某结点的孩子结点，不适用于查找其父结点。
  
• C实现

#define _CRT_SECURE_NO_WARNINGS 1
#define MAX_SIZE 20
#define TElemType char
#include<stdio.h>
#include<stdlib.h>

//孩子表示法
typedef struct CTNode {
    int child;//链表中每个结点存储的不是数据本身，而是数据在数组中存储的位置下标
    struct CTNode* next;
}ChildPtr;
typedef struct {
    TElemType data;//结点的数据类型
    ChildPtr* firstchild;//孩子链表的头指针
}CTBox;
typedef struct {
    CTBox nodes[MAX_SIZE];//存储结点的数组
    int n, r;//结点数量和树根的位置
}CTree;
//孩子表示法存储普通树
CTree initTree(CTree tree) 
{
    printf("输入节点数量：\n");
    scanf("%d", &(tree.n));
    for (int i = 0; i < tree.n; i++) {
        printf("输入第 %d 个节点的值：\n", i + 1);
        getchar();
        scanf("%c", &(tree.nodes[i].data));
        tree.nodes[i].firstchild = (ChildPtr*)malloc(sizeof(ChildPtr));
        tree.nodes[i].firstchild->next = NULL;
        printf("输入节点 %c 的孩子节点数量：\n", tree.nodes[i].data);
        int Num;
        scanf("%d", &Num);
        if (Num != 0) {
            ChildPtr* p = tree.nodes[i].firstchild;
            for (int j = 0; j < Num; j++) {
                ChildPtr* newEle = (ChildPtr*)malloc(sizeof(ChildPtr));
                newEle->next = NULL;
                printf("输入第 %d 个孩子节点在顺序表中的位置", j + 1);
                scanf("%d", &(newEle->child));
                p->next = newEle;
                p = p->next;
            }
        }
    }
    return tree;
}
void findKids(CTree tree, char a) {
    int hasKids = 0;
    for (int i = 0; i < tree.n; i++) {
        if (tree.nodes[i].data == a) {
            ChildPtr* p = tree.nodes[i].firstchild->next;
            while (p) {
                hasKids = 1;
                printf("%c ", tree.nodes[p->child].data);
                p = p->next;
            }
            break;
        }
    }
    if (hasKids == 0) {
        printf("此节点为叶子节点");
    }
}
int main()
{
    CTree tree;
    for (int i = 0; i < MAX_SIZE; i++) {
        tree.nodes[i].firstchild = NULL;
    }
    tree = initTree(tree);
    //默认数根节点位于数组notes[0]处
    tree.r = 0;
    printf("找出节点 F 的所有孩子节点：");
    findKids(tree, 'F');
    return 0;
}

• 将双亲表示法和孩子表示法合二为一，既能快速找到指定节点的父节点，又能快速找到指定节点的孩子节点。存储效果如下图所示：
  

【 3. 树的孩子兄弟表示法 】

• 树结构中，位于同一层的节点之间互为兄弟节点。例如下图的普通树中，节点 A、B 和 C 互为兄弟节点，而节点 D、E 和 F 也互为兄弟节点。
  
• 孩子兄弟表示法，采用的是 链式存储结构 。其存储树的实现思想是：从树的根节点开始，依次用链表存储各个节点的孩子节点和兄弟节点。
• 因此，该链表中的节点应包含以下 3 部分内容（如下图 所示）：
  1.节点的值；
  2.指向孩子节点的指针；
  3.指向兄弟节点的指针；
  
• C 语言代码表示节点结构为：

#define ElemType char
typedef struct CSNode{
    ElemType data;
    struct CSNode * firstchild,*nextsibling;
}CSNode,*CSTree;

• 以上上张图为例，使用孩子兄弟表示法进行存储的结果如图所示：
  
• 通过孩子兄弟表示法，任意一棵普通树都可以相应转化为一棵二叉树，换句话说， 任意一棵普通树都有唯一的一棵二叉树于其对应 。因此，孩子兄弟表示法通常又被称为 二叉树表示法 或 二叉链表表示法 。