• 线索二叉树

    目录

    一、线索二叉树的类型定义

    二、各种线索化的二叉树

    三、中序线索二叉树的算法

     完整代码

    四、有关哈夫曼树的定义

    哈夫曼编码

    一、线索二叉树的类型定义

    1. typedef struct BTNode
    2. {
    3.     ElemType data;//数据域
    4.     struct BTNode* lchild;//左孩子或线索指针
    5.     struct BTNode* rchild;//右孩子或线索指针
    6.     int ltag, rtag;
    7. }BTNode, * BTree;
    •  左标志ltag=0，表示lchild指向左孩子结点；ltag=1，表示lchild指向前驱结点
    • 右标志rtag=0，表示rchild指向右孩子结点；rtag=1，表示rchild指向后继结点
    • 二叉树线索化的基本思想：
    • 二叉树的线索化实质上是遍历一棵二叉树。在遍历过程中，访问结点的操作是检查此结点的左、右指针域是否为空，如果为空，将它指向其前驱或后继结点的线索

    二、各种线索化的二叉树

     

    •  为了操作方便，在存储线索二叉树的时候增设一个头结点，其结构与其他的线索二叉树的结点相同，只是数据域不存储任何数据，其左指针域指向二叉树的根结点，右指针指向遍历的最后一个结点，而二叉树在某种遍历下的第一个结点的前驱和最后一个结点的后继线索都指向头结点。

    三、中序线索二叉树的算法

    • 第一种方法建立并且遍历中序线索二叉树： 
    1. //第一种方法
    2. void CreatInThread(BTree &T);建立中序线索树
    3. void InThread(BTree& T);//中序遍历二叉树，一边遍历一边线索化
    4. void visit(BTree& q);//访问根结点
    5. void visit2(BTree T);//遍历输出中序线索二叉树
    1. BTNode* pre = NULL;//定义全局变量
    2.  
    3. void CreatInThread(BTree& T)//建立中序线索树
    4. {
    5.     pre = NULL;
    6.     if (T != NULL)
    7.     {
    8.         InThread(T);//中序线索化二叉树
    9.         if (pre!=NULL&&pre->rchild == NULL)
    10.         {
    11.             pre->rtag = 1;
    12.         }
    13.     }
    14. }
    15.  
    16. void InThread(BTree& T)//中序遍历二叉树，一边遍历一边线索化
    17. {
    18.     if (T != NULL)
    19.     {
    20.         InThread(T->lchild);//左子树递归线索化
    21.         visit(T);//访问根结点同时线索化
    22.         InThread(T->rchild);//右子树递归线索化
    23.     }
    24. }
    25.  
    26. void visit(BTree& q)//访问根结点
    27. {
    28.     if (q->lchild == NULL)//左子树为空的时候，让其前驱线索指向空
    29.     {
    30.         q->lchild = pre;
    31.         q->ltag = 1;
    32.      }
    33.     else
    34.     {
    35.         q->ltag = 0;
    36.     }
    37.     if (pre != NULL && pre->rchild == NULL)
    38.     {
    39.         pre->rchild = q;//建立前驱结点的后继线索（让前驱结点的rchild域存放后继结点的地址）
    40.         pre->rtag = 1;
    41.     }
    42.     else
    43.     {
    44.         q->rtag = 0;
    45.     }
    46.     pre = q;
    47. }
    48.  
    49. void visit2(BTree T)//遍历中序线索二叉树
    50. {
    51.     BTNode* p = T;
    52.     while (p != NULL)
    53.     {
    54.         while (p->ltag == 0)//找开始结点
    55.         {
    56.             p = p->lchild;
    57.         }
    58.         cout << p->data << " ";//找到中序遍历最开始的结点并输出其data的值
    59.         while (p->rtag == 1 && p->rchild != NULL)
    60.         {
    61.             p = p->rchild;
    62.             cout << p->data << " ";
    63.         }
    64.         p = p->rchild;
    65.     }
    66.     return;
    67. }
    •  第二种方法建立并且遍历中序线索二叉树：
    1. //第二种方法
    2. BTree CreatBTree(BTree& T);//中序线索化二叉树，先创建头结点root
    3. void Thread(BTree& T);//中序线索化二叉树
    4. void ThInOrder(BTree T);//在中序线索化二叉树中实现中序遍历（输出）
    1. BTree CreatBTree(BTree & T)//中序线索化二叉树，先创建头结点root
    2. {
    3.     BTNode* root = (BTNode*)malloc(sizeof(BTNode));//创建一个头结点
    4.     if (root == NULL)
    5.     {
    6.         exit(0);
    7.     }
    8.     root->ltag = 0;
    9.     root->rtag = 1;
    10.     root->rchild = T;
    11.     if (T == NULL)//空二叉树
    12.     {
    13.         root->lchild = root;
    14.     }
    15.     else
    16.     {
    17.         root->lchild = T;//头结点的lchild域存放二叉树根结点的地址
    18.         pre = root;
    19.         Thread(T);//中序线索化二叉树
    20.         pre->rchild = root;//最后处理加入头结点的线索
    21.         pre->rtag = 1;
    22.         root->rchild = pre;//头结点线索化
    23.  
    24.     }
    25.     return root;
    26. }
    27.  
    28. void Thread(BTree& T)//中序线索化二叉树
    29. {
    30.     if (T != NULL)
    31.     {
    32.         Thread(T->lchild);//左子树线索化
    33.         if (T->lchild == NULL)
    34.         {
    35.             T->lchild = pre;//建立当前结点的前驱线索
    36.             T->ltag = 1;
    37.         }
    38.         else
    39.         {
    40.             T->ltag = 0;
    41.         }
    42.         if (pre != NULL && pre->rchild == NULL)
    43.         {
    44.             pre->rchild = T;//建立前驱结点的后继线索
    45.             pre->rtag = 1;
    46.         }
    47.         else
    48.         {
    49.             if (pre != NULL)
    50.             {
    51.                 pre->rtag = 0;
    52.             }
    53.         }
    54.         pre = T;
    55.         Thread(T->rchild);//右子树线索化
    56.     }
    57. }
    58.  
    59.  
    60. void ThInOrder(BTree tb)//tb指向中序线索二叉树的头结点
    61. {
    62.     BTNode* p = tb->lchild;
    63.     while (p != tb)
    64.     {
    65.         while (p->ltag == 0)//找中序二叉树的开始结点（开始结点在最左下方）
    66.         {
    67.             p = p->lchild;
    68.         }
    69.         cout << p->data << " ";
    70.         while (p->rtag == 1 && p->rchild != tb)
    71.             //p->rtag=1并且p->rchild!=头结点表示p结点的rchild域存放的是中序遍历的后继结点的地址（线索）
    72.         {
    73.             p = p->rchild;//沿右线索访问后继结点
    74.             cout << p->data << " ";
    75.         }
    76.         p = p->rchild;//转向p的右子树
    77.     }
    78.        
    79.     
    80. }

    •  完整代码

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. using namespace std;
    6. #define MAXSIZE 100
    7. typedef char ElemType;
    8. typedef struct BTNode
    9. {
    10.     ElemType data;//数据域
    11.     struct BTNode* lchild;//左孩子或线索指针
    12.     struct BTNode* rchild;//右孩子或线索指针
    13.     int ltag, rtag;
    14. }BTNode, * BTree;
    15.  
    16. BTree Creat(char str[]);//先序序列建立二叉链表
    17.  
    18. void PreOrder(BTree T);//先序遍历
    19. void InOrder(BTree T);//中序遍历
    20. void PostOrder(BTree T);//后序遍历
    21. void LevelOrder(BTree T);//层序遍历
    22.  
    23.  
    24. //第一种方法
    25. void CreatInThread(BTree &T);建立中序线索树
    26. void InThread(BTree& T);//中序遍历二叉树，一边遍历一边线索化
    27. void visit(BTree& q);//访问根结点
    28. void visit2(BTree T);//遍历输出中序线索二叉树
    29.  
    30.  
    31. //第二种方法
    32. BTree CreatBTree(BTree& T);//中序线索化二叉树，先创建头结点root
    33. void Thread(BTree& T);//中序线索化二叉树
    34. void ThInOrder(BTree T);//在中序线索化二叉树中实现中序遍历（输出）
    35.  
    36. //找后继结点
    37. bool InPostNode(BTree& s);//寻找中序线索二叉树的的后继结点

    1. #include"TBTree.h"
    2. BTree Creat(char str[])//先序序列建立二叉链表（方法1）
    3. {
    4.     BTree T;
    5.     static int i = 0;
    6.     ElemType c = str[i++];
    7.     if (c == '#')//输入#表示此结点下不存在分支
    8.     {
    9.         T = NULL;
    10.     }
    11.     else
    12.     {
    13.         T = (BTree)malloc(sizeof(BTree));
    14.         if (T == NULL)
    15.         {
    16.             exit(0);
    17.         }
    18.         T->data = c;
    19.         T->lchild = Creat(str);//递归创建左子树
    20.         T->rchild = Creat(str);//到上一个结点的右边递归创建左右子树
    21.     }
    22.     return T;
    23. }
    24.  
    25. BTNode* pre = NULL;//定义全局变量
    26.  
    27. void CreatInThread(BTree& T)//建立中序线索树
    28. {
    29.     pre = NULL;
    30.     if (T != NULL)
    31.     {
    32.         InThread(T);//中序线索化二叉树
    33.         if (pre!=NULL&&pre->rchild == NULL)
    34.         {
    35.             pre->rtag = 1;
    36.         }
    37.     }
    38. }
    39.  
    40. void InThread(BTree& T)//中序遍历二叉树，一边遍历一边线索化
    41. {
    42.     if (T != NULL)
    43.     {
    44.         InThread(T->lchild);//左子树递归线索化
    45.         visit(T);//访问根结点同时线索化
    46.         InThread(T->rchild);//右子树递归线索化
    47.     }
    48. }
    49.  
    50. void visit(BTree& q)//访问根结点
    51. {
    52.     if (q->lchild == NULL)//左子树为空的时候，让其前驱线索指向空
    53.     {
    54.         q->lchild = pre;
    55.         q->ltag = 1;
    56.      }
    57.     else
    58.     {
    59.         q->ltag = 0;
    60.     }
    61.     if (pre != NULL && pre->rchild == NULL)
    62.     {
    63.         pre->rchild = q;//建立前驱结点的后继线索（让前驱结点的rchild域存放后继结点的地址）
    64.         pre->rtag = 1;
    65.     }
    66.     else
    67.     {
    68.         q->rtag = 0;
    69.     }
    70.     pre = q;
    71. }
    72.  
    73. bool InPostNode(BTree& s)//寻找中序线索二叉树的的后继结点
    74. {
    75.     BTNode* post;
    76.     post = s->rchild;
    77.     if (s->rtag != 1)//结点s有右孩子
    78.     {
    79.         while (post->ltag == 0)//从右子树的根结点开始，沿左指针域往下查找，
    80.             //直到没有左孩子为止
    81.         {
    82.             post = post->lchild;
    83.         }
    84.     }
    85.     s = post;
    86.     return true;
    87. }
    88.  
    89.  
    90. void visit2(BTree T)//遍历中序线索二叉树
    91. {
    92.     BTNode* p = T;
    93.     while (p != NULL)
    94.     {
    95.         while (p->ltag == 0)//找开始结点
    96.         {
    97.             p = p->lchild;
    98.         }
    99.         cout << p->data << " ";//找到中序遍历最开始的结点并输出其data的值
    100.         while (p->rtag == 1 && p->rchild != NULL)
    101.         {
    102.             p = p->rchild;
    103.             cout << p->data << " ";
    104.         }
    105.         p = p->rchild;
    106.     }
    107.     return;
    108. }
    109.  
    110.  
    111.  
    112.  
    113.  
    114. BTree CreatBTree(BTree & T)//中序线索化二叉树，先创建头结点root
    115. {
    116.     BTNode* root = (BTNode*)malloc(sizeof(BTNode));//创建一个头结点
    117.     if (root == NULL)
    118.     {
    119.         exit(0);
    120.     }
    121.     root->ltag = 0;
    122.     root->rtag = 1;
    123.     root->rchild = T;
    124.     if (T == NULL)//空二叉树
    125.     {
    126.         root->lchild = root;
    127.     }
    128.     else
    129.     {
    130.         root->lchild = T;//头结点的lchild域存放二叉树根结点的地址
    131.         pre = root;
    132.         Thread(T);//中序线索化二叉树
    133.         pre->rchild = root;//最后处理加入头结点的线索
    134.         pre->rtag = 1;
    135.         root->rchild = pre;//头结点线索化
    136.  
    137.     }
    138.     return root;
    139. }
    140.  
    141. void Thread(BTree& T)//中序线索化二叉树
    142. {
    143.     if (T != NULL)
    144.     {
    145.         Thread(T->lchild);//左子树线索化
    146.         if (T->lchild == NULL)
    147.         {
    148.             T->lchild = pre;//建立当前结点的前驱线索
    149.             T->ltag = 1;
    150.         }
    151.         else
    152.         {
    153.             T->ltag = 0;
    154.         }
    155.         if (pre != NULL && pre->rchild == NULL)
    156.         {
    157.             pre->rchild = T;//建立前驱结点的后继线索
    158.             pre->rtag = 1;
    159.         }
    160.         else
    161.         {
    162.             if (pre != NULL)
    163.             {
    164.                 pre->rtag = 0;
    165.             }
    166.         }
    167.         pre = T;
    168.         Thread(T->rchild);//右子树线索化
    169.     }
    170. }
    171.  
    172.  
    173. void ThInOrder(BTree tb)//tb指向中序线索二叉树的头结点
    174. {
    175.     BTNode* p = tb->lchild;
    176.     while (p != tb)
    177.     {
    178.         while (p->ltag == 0)//找中序二叉树的开始结点（开始结点在最左下方）
    179.         {
    180.             p = p->lchild;
    181.         }
    182.         cout << p->data << " ";
    183.         while (p->rtag == 1 && p->rchild != tb)
    184.             //p->rtag=1并且p->rchild!=头结点表示p结点的rchild域存放的是中序遍历的后继结点的地址（线索）
    185.         {
    186.             p = p->rchild;//沿右线索访问后继结点
    187.             cout << p->data << " ";
    188.         }
    189.         p = p->rchild;//转向p的右子树
    190.     }
    191.        
    192.     
    193. }
    194.  
    195. void PreOrder(BTree T)//先序遍历
    196. {
    197.     if (T != NULL)
    198.     {
    199.         cout << T->data << " ";//访问根结点
    200.         PreOrder(T->lchild);//先序遍历左子树
    201.         PreOrder(T->rchild);//先序遍历右子树
    202.     }
    203. }
    204.  
    205. void InOrder(BTree T)//中序遍历
    206. {
    207.     if (T != NULL)
    208.     {
    209.         InOrder(T->lchild);
    210.         cout << T->data << " ";
    211.         InOrder(T->rchild);
    212.     }
    213.  
    214. }
    215. void PostOrder(BTree T)//后序遍历
    216. {
    217.     if (T != NULL)
    218.     {
    219.         PostOrder(T->lchild);
    220.         PostOrder(T->rchild);
    221.         cout << T->data << " ";
    222.     }
    223. }
    224.  
    225.  
    226. void LevelOrder(BTree T)//层序遍历
    227. {
    228.     BTNode* p;
    229.     BTNode* qu[MAXSIZE];//定义循环队列，存放结点指针
    230.     int front, rear;//定义头指针和尾指针
    231.     front = rear = 0;//置队列为空队列
    232.     rear++;
    233.     qu[rear] = T;//根结点指针进队
    234.     rear++;//队尾指针指向队尾元素的后一个位置
    235.     front = (front + 1) % MAXSIZE;//队头指针加1取模
    236.     while (front != rear)//队列不为空
    237.     {
    238.         p = qu[front];//取队头元素
    239.         front = (front + 1) % MAXSIZE;//队头元素出队，队头指针后移
    240.         cout << p->data << " ";
    241.         if (p->lchild != NULL)
    242.         {
    243.             qu[rear] = p->lchild;//p结点的左孩子进栈
    244.             rear = (rear + 1) % MAXSIZE;//队尾指针加1取模
    245.         }
    246.         if (p->rchild != NULL)
    247.         {
    248.             qu[rear] = p->rchild;//p结点的右孩子进栈
    249.             rear = (rear + 1) % MAXSIZE;
    250.         }
    251.     }
    252. }
    1. #include"TBTree.h"
    2.  
    3. int main()
    4. {
    5. 	cout << "二叉树建立的第一种方法" << endl;
    6. 	BTree T;//T为指向根结点的指针
    7. 	T = (BTree)malloc(50*sizeof(BTree));
    8. 	char str[] = { 'a','b','d','#','g','#','#','#','c','e','#','#','f','#','#' };
    9. 	T = Creat(str);
    10. 	cout << "先序遍历结果：";
    11. 	PreOrder(T);//先序遍历
    12. 	cout << endl;
    13. 	cout << "中序遍历结果：";
    14. 	InOrder(T);//中序遍历
    15. 	cout << endl;
    16. 	cout << "后序遍历结果：";
    17. 	PostOrder(T);//后序遍历
    18. 	cout << endl;
    19. 	cout << "层次遍历的结果：";
    20. 	LevelOrder(T);
    21. 	cout << endl << endl;
    22.  
    23.  
    24. 	/*cout << "中序线索树遍历结果：";
    25. 	CreatInThread(T);
    26. 	visit2(T);
    27. 	cout << endl << endl;*/
    28.  
    29.  
    30. 	cout << "中序遍历结果2：";
    31. 	BTree tb;
    32. 	tb = (BTree)malloc(50*sizeof(BTree));
    33.  
    34. 	tb = CreatBTree(T);
    35. 	ThInOrder(tb);
    36. 	//system("pause");
    37. 	return 0;
    38. }
    39.

    四、有关哈夫曼树的定义

    • 路径：是指从一个结点到另一个结点之间的分支序列。
    • 路径长度：是指从一个结点到另一个结点所经过的分支数目。
    • 哈夫曼树：也称最优二叉树，是指对于一组带有确定权值的叶结点，构造的具有最小带权路径长度的二叉树

    • 哈夫曼树的构造步骤：

    给定n个权值分别为w1，w2...wn的结点
    1.将这n个结点分别作为n棵仅含一个结点的二叉树，构成森林F
    2.构造一个新的结点，从F中选取两棵根结点权值最小的树作为新结点的左，右子树，并且将
    新结点的权值置为左、右子树上根结点的权值之和。
    3.从F中删除刚才选出的两棵树，同时将新得到的树加入F中。
    4.重复步骤2和3，直至F中只剩下一棵树为止。 

     

    哈夫曼编码

    • 固定长度编码：每个字符用相等长度的二进制位表示

    例如：A--00；B--01；C--10；D--11

    • 可变长度编码：允许对不同字符用不等长的二进制位表示

    例如：C--0；A--10；B--111；D--110

    • 前缀编码：若没有一个编码是另一个编码的前缀，则称这样的编码为前缀编码

    由哈夫曼树得到的哈夫曼编码--字符集中每个字符作为一个叶子结点，各个字符出现的频度作为
    结点的权值。
     

  • 相关阅读:
    maven本地仓库同步上传到nexus远程仓库
    RabbitMQ 常用运维命令
    八皇后问题的解析与实现
    React 多环境运行打包配置(版本区分)
    双非本计算机从零开始三年努力能做到什么程度【学习路线回顾&总结&问答】
    WiFi密码别问了，这神器帮你搞定一切！
    测试工作十年，想对还在迷茫的朋友说：一点要做好个人规划...
    Go中的泛型和反射以及序列化
    【树莓派 Pico 基于Arduino IDE编程开发】
    计算机网络核心知识之Internet应用服务（超细致）
  • 原文地址：https://blog.csdn.net/m0_63783532/article/details/127992468