第六章_树【数据结构】

最新推荐文章于 2024-09-12 17:17:36 发布

陌上人如玉..

最新推荐文章于 2024-09-12 17:17:36 发布

阅读量240

点赞数

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/m0_61466355/article/details/127818185

版权

数据结构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

一、二叉树性质
二、二叉树非递归遍历
三、扩展先序遍历创建二叉链表
四、线索二叉树
五、树、森林与二叉树的转换
- 1.树转二叉树
- 2.森林转二叉树
六、哈夫曼树
- 1.建立哈夫曼树
- 2.哈夫曼编译码

一、二叉树性质

总结点数 N = n0 + n1 + n2
n0 = n2 + 1、
已知先序和中序，先序的第一个是根节点
已知中序和后序，后序的最后一个是根节点

二、二叉树非递归遍历

typedef struct NOde{
    char data;
    struct Node * left;
    struct Node * right;
}BiNode,*BiTree;

typedef struct{
    char data[100];
    int top;
}SeqStack;

1.前序遍历(中左右)

/*
	(1)访问根节点，根节点入栈并进入左子树，一直访问左子树的根节点并入栈，并进入下一层的左子树...，直到当前节点为空
	(2)栈非空就找到上一个栈顶节点，并访问其右子树
	(3)重复上述(1)、(2)两步骤，直至当前结点及栈均为空，结束。
	
    上述遍历过程，可简单地概括为如下算法。
    从根开始，当前结点存在或栈不为空，重复如下两步操作。
    (1)访问当前结点，当前结点进栈，进人其左子树，重复直至当前结点为空。
    (2)若栈非空，则退栈顶结点，并进入其右子树。
*/
void PreOrder(BiTree root){
    SeqStack *S;
    BiTree p = root;
    InitStack(S);
    while(p != NULL || !IsEmpty(S)){ //当前节点不为空或之前节点不为空
        while(p != NULL){ //先找左
            Visit(p->data);//访问
            Push(S,p);//当前节点入栈
            p = p->left;//找下一个左节点
        }
        if(!IsEmpty(S)){ //此时当前节点为空，开始找之前有没有节点
            Pop(S,&p); //找到上一个节点
            p = p->right; //找其右节点
        }
    }
}

2.中序遍历(左中右)

/*
	利用栈实现二叉树的中序非递归遍历过程如下。
	(1)根结点人栈，进人其左子树，进而左子树的根结点人栈，进人下一层左子树...，如此重复，直至当前结点为空。
	(2)若栈非空，则从栈顶退出上一层的结点，访问出栈结点，并进人其右子树
	(3)重复上述(1)、(2)两步骤，直至当前结点及栈均为空，结束。
	
    上述遍历过程，可简单的概括为如下算法。
    从根开始，当前结点存在或栈不为空，重复如下两步操作。
    (1)当前结点进栈，进人其左子树，重复直至当前结点为空。
    (2)若栈非空，则退栈，访问出栈结点，并进人其右子树。
*/
void InOrder1(BiTree root){
    SeqStack *S;
    BiTree p = root;
    InitStack(S);
    while(p != NULL || !IsEmpty(S)){
        while (p!=NULL){
            Push(S,p);
            p=p->LChild;
        }
    	if(!IsEmpty(S)){
            Pop(S,&p);
            Visit(p->data);
            p=p->RChild;
        }
    }
}
void InOrder2 (BiTree root){
    SeqStack *S;
    BiTree p = root;
    InitStack(S);
    while(p!=NULL || !IsEmpty(S)){
        if (p!=NULL){
            Push(s,p);
            p=p->LChild;
        }else{
            Pop(S,&p);
            Visit(p->data);
            p=p->RChild;
        }
    }
}

3.后序遍历(左右中)

/*
    后序遍历的非递归算法比先序、中序遍历算法复杂。在先序、中序遍历算法中，从左子树返回时，上一层结点先退栈，再访问其右子树。而后序遍历中，左、右子树均访问完成后，从右子树返回时，上一层结点才能退栈并被访问。由此产生如下问题:当从子树返回时，如何有效地判断是从左子树返回的，还是从右子树返回的，以便确定栈顶的上一层结点是否应出栈。解决该问题的方法有多种。方法之一是设置标记，每个结点人栈时加上一个标记位tag同时人栈，进左子树访问时置tag=0，进右子树访问时置tag=1，当从子树返回时，通过判断tag的值决定下一步的动作，此方法的算法实现留给读者自己完成.
	在此介绍另一种方法:判断刚访问的结点是不是当前栈顶结点的右孩子，以确定是否是从右子树返回。具体做法是从子树返回时，判断栈顶结点p的右子树是否为空?刚访同过的结点q是否是p的右孩子，是，说明p无右子树或右子树刚访问过，此时应退栈、访问出栈的p结点，并将p赋给q(q始终记录刚访问的结点)，然后将p赋为空(p置空可避免再次进人该棵树访问);不是，说明p有右子树且右子树未访问，则应进入p的右子树访问。
	
综上所述，利用栈实现二叉树的后序非递归遍历过程如下。

	(1)根结点人栈，进入其左子树，进而左子树的根结点入栈，进人下一层左子树，，如此重复，直至当前结点为空。
	(2)若栈非空，如果栈顶结点p的右子树为空，或者p的右孩子是刚访问的结点q，则退栈、访问p结点，并将p赋给q，然后p置为空;如果栈顶结点p有右子树且右子树未访问，则进入p的右子树。
	(3)重复上述(1)、(2)两步骤，直至当前结点及栈均为空，结束。
	
上述遍历过程，可简单地概括为如下算法。
    从根开始，当前结点存在或栈不为空，重复如下两步操作,
    (1)当前结点进栈，并进人其左子树，重复直至当前结点为空。
    (2)若栈非空，判栈顶结点p的右子树是否为空、右子树是否刚访问过，是，则退栈、访问p结点，p赋给q，p置为空;不是，则进人p的右子树
*/
void PostOrder(BiTree root){
    SeqStack *S;
    BiTree p,q;
    InitStack(S);
    p=root;
    q=NULL;
    while(p!=NULL || !IsEmpty(S)){
        while (p!=NULL){
            Push(S,p);
            p=p->LChild;
        }
        if(!IsEmpty(S)){
            Top(S,&p); //取出栈顶节点
            if((p->RChild==NULL)||(p->RChild==q)){ //栈顶节点此时应该出栈
                Pop(S,&p);
                visit(p->data);
                q=p; //q指向上一个刚访问的节点
                p=NULL; //避免以后找到p
            }else{
             	p=p->RChild;
            }
        }
    }
}

三、扩展先序遍历创建二叉链表

void CreateBiTree(BiTree * root){
    char ch;
    ch = getchar();
    if(ch == '#'){
        *root = NULL;
        return;
    }
    (*root) = (BiTree)malloc(sizeof(BiTNode));
    (*root)->data = ch;
    CreateBiTree(&((*root)->LChild));
    CreateBiTree(&((*root)->RChild));
}

四、线索二叉树

(1)若结点有左子树，则LChild域仍指向其左孩子;否则，LChild域指向其某种遍历序列中的直接前驱结点。

(2)若结点有右子树，则RChild域仍指向其右孩子;否则，RChild域指向其某种遍历序列中的直接后继结点。

(3)为避免混淆，结点结构增设两个布尔型的标志域:Ltag和Rtag，其含义如下:

Ltag: 0 LChild指示结点左孩子 1 指示结点的遍历前驱

Rtag: 0 RChild指示结点右孩子 1 指示结点的遍历后继

1.二叉树中序线索化

(1) 当左孩子为空时，此时找前驱结点，就是刚刚访问的结点，设置一个指针 pre，始终指向刚刚访问过的结点，当左孩子为空时，将pre赋给左孩子，将 Ltag 置为1，pre初始化 NULL

(2) 当右孩子为空时，此时填后继结点，就是下一个访问的结点，只有访问到下一个结点才知道，其实当前结点就是pre结点的后继，所以在遍历每一个结点时，应回填pre的后继指针。应判pre的右孩子域是否为空，为空则将当前结点指针赋给pre的右孩子域，同时将pre的Rtag置为1

/*二叉树的中序线索化*/
void Inthread(BiTree root){
	if(root == NULL){
        return;
    }  
    Inthread(root->LChild);	//线索化左子树
    if(root->LChild == NULL){ //找前驱
        root->LChild = pre;
        root->Ltag = 1;
    }
    if(pre != NULL && pre->RChild == NULL){	//找后继
        pre->RChild = root;
        pre->Rtag = 1;
    }
    pre = root;
    Inthread(root->RChild); //线索化右子树
}

2.在中序线索二叉树找前驱、后继结点

1.查找前驱

当结点p->Ltag = 1，p->LChild指向前驱，当p->Ltag = 0时，p->LChild指向p的左孩子，p的前驱结点，是中序遍历p的左子树时访问的最后一个结点（左子树的最右下端的结点）

BiThrTree InPre(BiThrTree p){
    if(p->Ltag == 1){
        pre = p->Child; //直接找到前驱
    } else{ //在左子树找最右下端的结点
        for(q = p->LChild;q->Rtag == 0;q = q->RChild){
            pre = q;
        }
    }
    return pre;
}

2.查找后继

当结点p->Rtag = 1，p->RChlid指向后继，当p->Rtag = 0时，p->RChild指向p的右孩子，p的后继结点，是中序遍历p的右子树时访问的第一个结点（右子树最左下端的结点）

BiThrTree InNext(BiThrTree p){
    if(p->Rtag = 1){
        next = p->RChild; //直接找到后继
    } else{ //在右子树找最左下端的结点
        for(q = p->RChild;q->Ltag == 0;q = q->LChild){
            next = q;
        }
    }
    return next;
}

3.遍历中序线索树

(1) 先求出第一个被访问的结点(对中序遍历来说就是最左下端的结点)

(2) 不断求出刚访问结点的遍历后继，进行访问，直到所有结点都被访问

/*
	在中序线索树中求遍历的第一个结点
*/
BiThrTree InFirst(BiThrTree bt){
    BiThrTree p = bt;
    if(p == NULL){
        return NULL;
    }
    while(p->Ltag == 0){
        p = p->LChild;
    }
    return p;
}

/*
	遍历中序二叉线索树
*/
void TinOrder(BiThrTree root){
    BiThrTree p;
    p = InFirst(bt);
    while(p != NULL){
        Visit(p->data);
        p = InNext(p);
    }
}

五、树、森林与二叉树的转换

1.树转二叉树

加线：兄弟加线
删线：每个结点只保留其与第一个孩子结点之间的连线，其他删掉
旋转调整：以根节点为轴心，顺时针旋转

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BdaXxknA-1668223711290)(C:\Users\shang\Desktop\数据结构c\课程\树\树转二叉树.jpg)]

2.森林转二叉树

转换：将每一颗树转换为二叉树
加线：相邻二叉树的根节点之间加线
旋转调整：以第一颗二叉树的根节点为轴心，顺时针转，即一次把后一颗二叉树的根节点调整到作为前一颗二叉树根节点的右孩子位置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PrawY9j9-1668223711292)(C:\Users\shang\Desktop\数据结构c\课程\树\森林转二叉树.jpg)]

六、哈夫曼树

1.建立哈夫曼树

WPL = 权值 * 路径长度

typedef struct{
    int weight;
    int parent;
    int Lchild;
    int Rchild;
}HTNode, HuffmanTree[M+1];

哈夫曼算法可分为初始化和构建哈大曼树两个部分

初始化所有结点:首先，构造个根结点，即将数组前个元索视为根结点，其权值置为W，孩子和双亲指针全置0;其次、置空后n-1个元素，初始时各域均置0。

构建哈夫曼树:在数组的已有结点中选双亲为0(即树根)且权值最小的两结点，构造新结点，新结点下标为数组中已有结点的后一个位置，其权值为选取的两权值最小结点的权值之和，其左、右孩了分别指向两权值最小结点，同时，两权值最小结点的双求应改为指向新结点。此过程要重复n-1次。

void CrtHuffmanTree(HuffmanTree ht , int w, int n){
    m=2*n-l;
    for(i = 1;i < n;i++){ //初始化前 n 个节点为根节点
        ht[i] = {w[i], 0, 0, 0};
    }
    for(i = n + 1;i <= m;i++){ //初始化后 n - 1 个空元素
        ht[i] = {0, 0, 0, 0};
    }
    for(i = n + 1;i <= m;i++){ //构建新结点
        select(ht, i-1, &s1, &s2); //在 ht 的前 i - 1项中选双亲为0且权值最小的两结点 s1, s2
        ht[i].weight = ht[s1].weight + ht[s2].weight; //建新结点，赋新权值
        ht[i].Lchild = s1; //赋新结点左右孩子指针
        ht[i].Rchild = s2;
        ht[s1].parent = i; //改 s1, s2双亲指针
        ht[s2].parent = i;
    }
}

2.哈夫曼编译码

前缀编码：同一字符集中任何一个字符的编码都不是另一个字符编码的前缀（最左子串）

实现哈夫曼编码

构造哈夫曼树
在哈夫曼树上求各叶子结点的编码

由于每个哈夫曼编码的长度不等、因此可以按编码的实际长度动态分配空间，但要使用个指针数组，存放每个编码小的头指针，其定义如下:

typedef char *Huffmancode[n+1]

在哈夫曼树上求各叶子结点的编码可以按如下方法进行。

(1)从叶子结点开始，沿结点的双亲链温溯到根结点，追溯过程中，每上升一层，则经过了一个分支，便可得到一位哈夫曼编码值，左分支得到‘0’，有分支得到‘1’

(2)由于从叶子追溯到根的过程所得到的吗中，价为哈夫曼编码的逆串，因此，在产生哈夫复编妈串时，使用一个临时效组cd，每位编码从后向前逐位放人cd中，由start指针控制存放的次序,

(3)到达根结点时，一个叶子的编码构造完成，此时将cd数组中 start为开始的串复制到动态中请的编码串空间即可,

以下是按上述方法思想编写的求哈夫曼编码的算法。

void CrtHufEmanCode1 (HuffmanTree ht,HuffmanCode hc,int n)
/*从叶子到根，逆向求各叶子结点的编码*/
{ 
    char *cd;
    int start:
    cd = (char*)malloc(n * sizeof(char)); //临时编码数组
    cd[n-1] = '\0'; //从后向前
    for(i = 1;i <= n;i++){ //从每个叶子结点开始
        start = n-1;
        c = i; //c为当前结点
        p = ht[i].parent; //p为c双亲
        while(p != 0){ //当双亲还在
            --start; //加一个编码
            if(ht[p].Lchild == c){ //判断编码什么
                cd[start] = '0';
            }else{
				cd[start] = '1';
            }
            c = p; //此时 p 为当前结点
            p = ht[p].parent; //更新双亲
        }
        hc[i] = (char*)malloc((n - start)*sizeof(char)); //编码完成，截取实际编码
        strcpy(hc[i],&cd[start]); //复制编码
    }
    free(cd);
}

–start; //加一个编码
if(ht[p].Lchild == c){ //判断编码什么
cd[start] = ‘0’;
}else{
cd[start] = ‘1’;
}
c = p; //此时 p 为当前结点
p = ht[p].parent; //更新双亲
}
hc[i] = (char*)malloc((n - start)*sizeof(char)); //编码完成，截取实际编码
strcpy(hc[i],&cd[start]); //复制编码
}
free(cd);
}