数据结构与算法·第6章【树】

树的相关定义

树的深度（高度）：树中叶子结点所在的最大层次

森林： $m$ 棵互不相交的树的集合

二叉树

二叉树或为空树，或是由一个根结点加上两棵分别称为左子树和右子树的、互不交的二叉树组成。

性质

二叉树，第 $i$ 层上至多有 $2^{i-1}$ 的结点（ $i \geq 1$ ）这个性质比较好理解，因为第i层是由i-1层引出的，再以此递归到根结点就很好理解
深度为 $k$ 的二叉树上至多含 $2^k-1$ 个结点（ $k \geq 1$ ）这个也很好理解，先把树想象成一棵满二叉树，因为根结点那层只有一个结点，所以减一即可
对任何一棵二叉树，若它含有 $n_0$ 个叶子结点、 $n_2$ 个度为 $2$ 的结点，则必存在关系式： $n_0 = n_2+1$
具有 n 个结点的完全二叉树的深度为 $log_2n+1$ 用第2条性质很好理解
对于含有 $n$ 个节点的完全二叉树，我们可以按照从上到下、从左到右的顺序为每个节点进行编号，从 $1$ 到 $n$ 。对于任意一个编号为 $i$ 的节点：
1. 如果 $i = 1$ ，那么该节点就是整棵二叉树的根节点，它没有父节点；否则，它的父节点的编号为 $\lfloor i/2 \rfloor$ 。
2. 如果 $2 i > n$ ，那么编号为 $i$ 的节点没有左孩子，否则，它的左孩子的编号为 $2 i$ 。
3. 如果 $2 i + 1 > n$ ，那么编号为 $i$ 的节点没有右孩子，否则，它的右孩子的编号为 $2 i + 1$ 。

完全二叉树：

完全二叉树是一种特殊的二叉树，它与普通的二叉树区别在于它的层数，及对于第 $i$ 层，如果该层的节点没有填满，则其所有节点都必须集中在左侧连续位置上。也就是说，完全二叉树中除最后一层外，其他层的节点数都达到了最大值，且最后一层的节点都集中在该层最左边的若干位置上。

存储结构

顺序存储

#define MAX_TREE_SIZE 100      
typedef TElemType SqBiTree[MAX_TREE_SIZE];   
// 0号单元存储根结点

SqBiTree bt;

二叉链表

// 定义二叉树结点和指向二叉树结点的指针类型
typedef struct BiTNode {
    
    
    TElemType data;             // 数据域
    struct BiTNode *lchild, *rchild; // 左右孩子指针
} BiTNode, *BiTree;

示意图

lchild	data	rchild

三叉链表

// 定义三叉链表结点和指向三叉链表结点的指针类型
typedef struct TriTNode {
    
    
    TElemType data;             // 数据域
    struct TriTNode *lchild, *rchild; // 左右孩子指针
    struct TriTNode *parent;    // 双亲指针
} TriTNode, *TriTree;

根节点的 $p a re n t$ 为NULL

parent	lchild	data	rchild

二叉树遍历

先序遍历根左右
中序遍历左根右
后序遍历左右根

先序遍历算法比较简单，我就不放了

中序遍历：

Status InOrderTraverse(BiTree T, Status (*Visit)(TElemType e)) {
    
    
    InitStack(S);
    Push(S, T); // 根指针进栈
    while (!StackEmpty(S)) {
    
    
        while (GetTop(S, p) && p) {
    
    
            Push(S, p->lchild); // 向左走到尽头
        }
        Pop(S, p); // 空指针退栈
        if (!StackEmpty(S)) {
    
     // 访问结点，向右一步
            Pop(S, p); 
            if (!Visit(p->data)) {
    
    
                return ERROR;
            }
            Push(S, p->rchild);
        }
    }
    return OK;
}

//采用非递归的方式，中序遍历以T为根指针的二叉树
Status InOrderTraverse(BiTree T, Status (*Visit)(TElemType e)){
    
    
    SqStack S;  //定义一个栈 S 来存储节点。
    InitStack(&S);  //初始化栈
    
    BiTree p = T;  //p为遍历指针，初始时指向根结点
    
    while (p || !StackEmpty(S)){
    
       //p非空或者栈不为空
        if (p){
    
       //如果p非空
            Push(&S, p);   //节点入栈
            p = p->lchild;   //遍历左子树
        }
        else{
    
      //如果p为空
            Pop(&S, &p);   //取出栈顶元素
            if (!Visit(p->data)) return ERROR;  //访问栈顶元素
            p = p->rchild;   //遍历右子树
        }   
    }
    return OK;
}

创建二叉树

//按照前序遍历方式，创建一棵二叉树，并返回 OK
Status CreateBiTree(BiTree &T) {
    
    
    char ch;  //定义一个字符类型的变量 ch 用于输入二叉树结点的值
    scanf("%c", &ch);  //从用户输入中读取下一个字符，即当前结点的值
    
    if (ch == ' ') T = NULL;  //如果输入的是空格，则表示该结点为空结点
    else {
    
       //否则，生成一个新的二叉树结点，并赋值为 ch
        if (!(T = (BiTNode *)malloc(sizeof(BiTNode))))
            exit(OVERFLOW);  //若生成结点失败，则退出程序
        T->data = ch;  //为当前结点赋值
        CreateBiTree(T->lchild);  //递归调用 CreateBiTree 函数构造左子树
        CreateBiTree(T->rchild);  //递归调用 CreateBiTree 函数构造右子树
    }
    return OK;  //返回 OK 表示创建成功
}

由先序和中序遍历构建二叉树：

在这里插入图片描述

由后序和中序构建：

在这里插入图片描述

线索二叉树

线索二叉树是在二叉树的基础上增加了线索信息的一种数据结构。线索二叉树的每个结点除了指向左右子树的指针外，还有两个特殊指针，分别称为前驱线索和后继线索指针，用来记录该结点在中序遍历中的前驱和后继结点。

在线索二叉树中，如果一个结点没有左子树，则将其左子树指针指向该结点在中序遍历中的前驱结点；如果一个结点没有右子树，则将其右子树指针指向该结点在中序遍历中的后继结点。当然并非一定中序遍历，只是书上的内容多是中序遍历

线索化过程即为将二叉树转换成线索二叉树的过程。线索化的方法主要有以下两种：

中序遍历线索化：对于给定的二叉树，中序遍历得到的结点序列中，每个结点都有唯一的前驱和后继。通过修改二叉树中的指针，使其变成一个线性的结构，同时保留原有的中序遍历序列，即可得到该二叉树的线索二叉树。
先序遍历线索化：与中序遍历类似，只是遍历顺序不同。

线索二叉树的主要优点是可以加快对二叉树的遍历操作，同时节省存储空间。缺点是线索化过程需要额外的时间开销，并且增加了代码的复杂度。

typedef enum {
    
     Link, Thread } PointerThr;  // Link==0:指针，Thread==1:线索

typedef struct BiThrNode {
    
    
    TElemType         data;      // 结点数据
    struct BiThrNode *lchild;    // 左子树指针
    struct BiThrNode *rchild;    // 右子树指针
    PointerThr        LTag;      // 左标志
    PointerThr        RTag;      // 右标志
} BiThrNode, *BiThrTree;

遍历算法

void InOrderTraverse_Thr(BiThrTree T, void (*Visit)(TElemType e)) {
    
    
    BiThrTree p = T->lchild;   // p指向根结点的左子树
    while (p != T) {
    
               // 空树或遍历结束时，p==T
        while (p->LTag == Link) p = p->lchild;  // 如果左标志为指针，则p进至其左子树的最左下结点
        if (!Visit(p->data)) return;            // 访问该结点，如果访问失败则返回错误
        while (p->RTag == Thread && p->rchild != T) {
    
    
            p = p->rchild;  Visit(p->data);      // 循环访问后继结点，直到遇到右标志为指针的结点
        }
        p = p->rchild;          // 如果右标志为指针，则p进至其右子树的根结点
    }
}

仔细看看吧，第一次看的时候还有点不理解

建立线索链表

Status InOrderThreading(BiThrTree &Thrt, BiThrTree T) {
    
    
    if (!T) {
    
      // 如果二叉树为空，则创建头结点并将左右指针都指向自身
        if (!(Thrt = (BiThrTree)malloc(sizeof(BiThrNode)))) {
    
    
            exit(OVERFLOW);
        }
        Thrt->LTag = Link;
        Thrt->RTag = Thread;
        Thrt->lchild = Thrt;
        Thrt->rchild = Thrt;
        return OK;
    }

    // 否则，创建头结点，并将左指针指向根节点，右指针指向尾节点
    if (!(Thrt = (BiThrTree)malloc(sizeof(BiThrNode)))) {
    
    
        exit(OVERFLOW);
    }
    Thrt->LTag = Link;
    Thrt->RTag = Thread;
    Thrt->rchild = Thrt;

    pre = Thrt;  // 初始化前驱节点，方便遍历时标记前驱线索

    Thrt->lchild = T;  // 左指针指向根节点
    InThreading(T);  // 中序遍历二叉树并进行线索化

    pre->rchild = Thrt;  // 将最后一个节点的右子树指针指向头结点
    pre->RTag = Thread;
    Thrt->rchild = pre;  // 将头结点的右指针指向最后一个节点

    return OK;
}

代码部分不用详细看了，主要是头结点左子树为根节点，右结点指向尾节点，最后一个节点的右子树指向头结点

首先判断输入的二叉树是否为空。如果为空，则创建一个头结点，并将左右指针都指向自身。否则，我们创建一个头结点，将其左指针指向根节点，将其右指针指向尾节点。

接下来，我们初始化前驱节点 pre，并将其指向头结点，以便遍历二叉树时能够方便地标记前驱线索。然后，我们将头结点的左指针指向根节点，调用函数 InThreading 对二叉树进行中序线索化。

在 InThreading 函数返回后，我们需要找到最后一个节点，并将它的右子树指针指向头结点。我们使用变量 pre 来保存当前遍历过的最后一个节点，在循环中不断更新，直到遍历到最后一个节点。最后，我们将最后一个节点的右子树指针指向头结点，并将头结点的右指针指向最后一个节点。

森林与树

表示法

双亲表示法
在这里插入图片描述

孩子链表表示法
在这里插入图片描述
比双亲表示法多了一个存储孩子的域空间

树的二叉链表（孩子-兄弟）表示法
在这里插入图片描述

左孩子-右兄弟

二叉树与森林的转换

在这里插入图片描述

遍历

树的遍历：

在这里插入图片描述
注意后根遍历——类似后序遍历
层次遍历——BFS

森林的遍历：
在这里插入图片描述

若森林不空，则可按下述规则遍历之：（先序遍历）
（1）访问森林中第一棵树的根结点；
（2）先序遍历森林中第一棵树的子树森林；
（3）先序遍历森林中(除第一棵树之外)其余树构成的森林。
若森林不空，则可按下述规则遍历之：（中序遍历）
（1）中序遍历森林中第一棵树的子树森林；
（2）访问森林中第一棵树的根结点；
（3）中序遍历森林中(除第一棵树之外)其余树构成的森林。

在这里插入图片描述
但是树的后根遍历不是对应中序遍历
后根遍历：

树的存储结构

typedef struct CSNode {
    
    
    Elem data;
    struct CSNode *left, *right;  // 左儿子和右兄弟指针
} CSNode, *CSTree;

左孩子-右兄弟

常见应用算法

求树的深度

int TreeDepth(CSTree T) {
    
    
    if (!T) {
    
    
        return 0;
    } else {
    
    
        int h1 = TreeDepth(T->left);     // 递归求左子树深度
        int h2 = TreeDepth(T->right);    // 递归求右子树深度
        return (h1 > h2 ? h1 : h2) + 1;  // 返回深度较大的子树深度加1
    }
} // TreeDepth

求从根到所有叶子的路径

void AllPath(Bitree T, Stack &S) {
    
    
    if (T) {
    
    
        Push(S, T->data);
        if (!T->left && !T->right) {
    
    
            PrintStack(S);
        } else {
    
    
            AllPath(T->left, S);
            AllPath(T->right, S);
        }
        Pop(S);
    }
} // AllPath

Huffman

结点的路径长度：

在这里插入图片描述

树的路径长度：从树根到每个结点的路径长度之和

结点的带权路径长度：从该结点到树根之间的路径长度与结点上权的乘积。

树的带权路径长度：树中所有叶子结点的带权路径长度之和。记作： WPL(T) = ∑w_kl_k (对所有叶子结点)。

构造最优二叉树的一种算法——huffman算法

霍夫曼算法的实现过程如下：

计算每个字符在文本中出现的频率；
将所有字符和其频率作为叶子节点构建一棵二叉树，其中节点的权重值为该节点代表的字符的频率；
对于这棵二叉树，从中选择两个权重值最小的节点作为左右子树，将它们的权重值相加并作为新节点的权重值；
将这个新节点作为子树的根节点，并将它插入到二叉树中原来两个被选中的节点所在的位置；
重复步骤 3 和 4 直到整棵树变成一个节点，这个节点就是霍夫曼树的根节点；
对于每个字符，从根节点开始，如果字符在左子树中，则输出0，否则输出1，直到找到对应的叶子节点；
将所有字符的编码串连接起来，就是压缩后的数据。

huffman结构体

typedef struct Node {
    
    
    int data;           // 节点存储的值
    unsigned int freq;  // 节点的频率（权重）
    struct Node *left;  // 左子节点
    struct Node *right; // 右子节点
} HTNode, *HuffmanTree;

huffman编码

编码部分可以用更好理解的递归来解决

void generateHuffmanCodes(HuffmanNode* root, string code) {
    
    
	if (!root) return;
	if (root->left == nullptr && root->right == nullptr) codes[root->ch] = code;
	generateHuffmanCodes(root->left, code + "0"); 
	generateHuffmanCodes(root->right, code + "1"); 
}

建huffman树用最小堆（更好理解一点）

Node* buildHuffmanTree(int data[], unsigned int freq[], int size) {
    
    
    Node *left, *right, *top;
    // 创建一个用于存储节点的最小堆
    MinHeap* minHeap = createMinHeap(size);
    // 将所有数据和频率构建为节点，并插入到最小堆中
    for (int i = 0; i < size; ++i) {
    
    
        insertMinHeap(minHeap, createNode(data[i], freq[i]));
    }
    // 从最小堆中取出两个具有最小频率的节点，并构建Huffman树
    while (!isSizeOne(minHeap)) {
    
    
        // 从最小堆中取出频率最小的两个节点
        left = extractMin(minHeap);
        right = extractMin(minHeap);
        // 创建一个新的节点作为它们的父节点，并设置频率为左右子节点的频率之和
        top = createNode('$', left->freq + right->freq);
        // 将左右子节点分别作为新节点的左右子节点
        top->left = left;
        top->right = right;
        // 将新节点插入到最小堆中
        insertMinHeap(minHeap, top);
    }
    // Huffman树的根节点即为最后剩下的节点
    return extractMin(minHeap);
}

习题

建立线索树

在这里插入图片描述

注意 $G$ 的前驱是 $N ULL$ （后序遍历）

根据中序遍历和后序遍历确定树

在这里插入图片描述

这道题有时间的话可以写写，第一次写的时候写错了

相似

若已知两棵二叉树 $B 1$ $B 2$ 皆为空，或者皆不空且 $B 1$ 的左、右子树和 $B 2$ 的左、右子树分别相似，则称二叉树 $B 1$ 和 $B 2$ 相似。试编写算法，判别给定两棵二叉树是否相似。
在这里插入图片描述
比较简单，但不妨看看

栈实现后序遍历

写出后序遍历的非递归算法（提示：为分辨后序遍历时两次进栈的不同返回点，需在指针进栈时同时将一个标志进栈）。

在这里插入图片描述
仔细看看

层次遍历

编写按层次顺序（同一层自左至右）遍历二又树的算法。

在这里插入图片描述

判断完全二叉树

bool full(tree t) {
    
    
    init_queue(q);
    int flag = 0;
    enqueue(q, t);
    while (!queue_empty(q)) {
    
    
        dequeue(q.p);
        if (!p) {
    
    
            flag = 1;
        } else if (flag) {
    
    
            return 0;
        } else {
    
    
            enqueue(q, p->lchild);
            enqueue(q, p->rchild);
        }
    }
    return 1;
}

求孩子-兄弟链的深度

typedef struct TreeNode * Tree;
int depth(Tree root) {
    
    
    if (!root) {
    
    
        return 0; // 如果节点为空，深度为 0
    }
    int maxDepth = 0;
    for (Tree p = root->firstChild; p; p = p->rightSibling) {
    
    
        int d = depth(p); // 递归计算子节点的深度
        if (d > maxDepth) {
    
    
            maxDepth = d; // 记录最大深度
        }
    }
    return maxDepth + 1; // 当前节点的深度等于最深子节点的深度加上 1
}

Tree p = root->firstChild; p; p = p->rightSibling
这一条代码可以好好看看

typedef struct TreeNode* tree;
int depth(tree root) {
    
    
     if (!root) {
    
    
         return 0;
     } else {
    
    
         return max(depth(root->firstChild) + 1, depth(root->rightSibling));
     }
}

自己后来写的，感觉更精简一些

依据前序序列和中序序列构建二叉树（二叉链表）

Tree buildTree(int preorder[], int inorder[], int n) {
    
    
    if (n == 0) {
    
    
        return NULL; // 当序列为空时，返回空指针
    }
    // 在前序序列中找到根节点
    int root_val = preorder[0];
    int i;
    for (i = 0; i < n; i++) {
    
    
        if (inorder[i] == root_val) {
    
    
            break;
        }
    }
    // 根据中序序列划分左右子树
    int left_size = i;
    int right_size = n - i - 1;
    // 递归构建左右子树
    Tree root = (Tree) malloc(sizeof(struct TreeNode));
    root->val = root_val;
    root->left = buildTree(preorder + 1, inorder, left_size);
    root->right = buildTree(preorder + 1 + left_size, inorder + 1 + left_size, right_size);
    return root;
}

依据递归解决即可