树的实现与操作(C语言实现)

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了树的实现与操作(C语言实现)，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8619字，纯文字阅读大概需要13分钟。

内容图文

首先来简单说下一些关于的基本概念。

树是一种非线性的数据结构

1 ，树是由 n(n>=0) 个结点组成的有限集合

如果 n = 0 , 称为空树

如果 n > 0, 则：

有一个特定的称之为根（ root ）的结点，它只有直接后继，但没有直接前驱

除了根以外的其他结点划分为： m(m>=0) 个互不相交的有限集合， T0,T1,T2…Tn-1, 每个集合又是一棵树，并且称之为根的子树

2 ，树中的概念：

树的结点包括一个数据及若干指向子树的分支

结点拥有的子树树称为结点的度

度为 0 的结点称为叶结点

度不为 0 的结点称为分支结点

树的度的定义为所有结点中的度的最大值

3,树中结点之间的关系

(1) 结点的直接后继称为该结点的孩子

(2) 相应的该结点称为孩子的双亲

(3) 结点的孩子的孩子的……称为该结点的子孙

(4) 相应的该结点称为子孙的祖先

(5) 同一个双亲的孩子之间互称兄弟

4，树的深度或高度

(1) 结点的层次

(2) 根为第 1 层

(3) 根的孩子为第 2 层

(4) ……

(5) 树中结点的最大层次称为树的深度或高度

5，如果树中结点的各子树从左向右是有次序的,子树间不能互换位置,则称该树为有序树,否则为无序树。

6，森林是由 n(n >=0 ) 棵互不相交的树组成的集合

7，树的相关操作

树的操作

树的一些常用操作

-> 创建树

-> 销毁树

-> 清空树

-> 插入结点

-> 删除结点

-> 获取结点

-> 获取根结点

-> 获取树的结点数

-> 获取树的高度

-> 获取树的度

树在程序中表现为一种特殊的数据类型

树的操作在程序中的表现为一组函数

Tree :

Tree*Tree_Create();

voidTree_Destroy(Tree* tree);

voidTree_Clear(Tree* tree);

intTree_Insert(Tree* tree, TreeNode* node, int pos);

TreeNode*Tree_Delete(Tree* tree, int pos);

TreeNode*Tree_Get(Tree* tree, int pos);

TreeNode*Tree_Root(Tree* tree);

intTree_Height(Tree* tree);

intTree_Count(Tree* tree);

intTree_Degree(Tree* tree);

再来说下，这里树的基本存储结构。假定我们初始有一棵树，那么我们如何来规定他的存储结构呢？

首先，我们规定每个树结点中有三个属性(1)表示其父亲的指针(2)表示结点中的数据(3)表示孩子的链表，这里为什么是个链表呢？因为一个结点的的孩子可能有一个，也有可能有多个，所以用一个链表表示最为合适了。

第二，每个树之间的关系，我们可以模仿二叉树中的先序遍历思想，对这颗树进行遍历，我们知道，遍历的结果肯定是个序列，那么我们此时就可以果断的把这种序列认为是一种链表结构，那么后期对于树的操作也就可以移植到链表上来了。

最后，关于树的深度、度、删除、根结点的获取与计算，都是在表示那颗树的结点上来操作的。那么这里特别说明一下，由于整个树存在两个链表，所以对于每次删除，插入都要向两个链表中删除和插入。（一个结点既要存在于他父亲的孩子链表中，又要存在于表示整棵树的链表中）

这里我们用到了链表的知识，如果对于链表不熟悉，可以参阅链表的实现与操作(C语言实现)。这里有详尽的代码。

源代码：

#ifndef _GTREE_H_
#define _GTREE_H_

typedef void GTree;
typedef void GTreeData;
typedef void (GTree_Printf)(GTreeData*);

GTree* GTree_Create();

void GTree_Destroy(GTree* tree);

void GTree_Clear(GTree* tree);

int GTree_Insert(GTree* tree, GTreeData* data, int pPos);

GTreeData* GTree_Delete(GTree* tree, int pos);

GTreeData* GTree_Get(GTree* tree, int pos);

GTreeData* GTree_Root(GTree* tree);

int GTree_Height(GTree* tree);

int GTree_Count(GTree* tree);

int GTree_Degree(GTree* tree);

void GTree_Display(GTree* tree, GTree_Printf* pFunc, int gap, char div);

#endif

CPP实现部分：

#include "stdafx.h"
#include <malloc.h>
#include "GTree.h"
#include "LinkList.h"

//树中的结点
typedef struct _tag_GTreeNode GTreeNode;
struct _tag_GTreeNode
{
    GTreeData* data;
    GTreeNode* parent;
    LinkList* child;
};

//树
typedef struct _tag_TLNode TLNode;
struct _tag_TLNode
{
    LinkListNode header;
    GTreeNode* node;
};


//打印树
static void recursive_display(GTreeNode* node, GTree_Printf* pFunc, int format, int gap, char div)
{
    int i = 0;
    
    if( (node != NULL) && (pFunc != NULL) )
    {
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
    
        pFunc(node->data);
    
        printf("\n");
    
        for(i=0; i<LinkList_Length(node->child); i++)
        {
            TLNode* trNode = (TLNode*)LinkList_Get(node->child, i);
            
            recursive_display(trNode->node, pFunc, format + gap, gap, div);
        }
    }
}

static void recursive_delete(LinkList* list, GTreeNode* node)
{
    if( (list != NULL) && (node != NULL) )
    {
        GTreeNode* parent = node->parent;
        int index = -1;
        int i = 0;
        //将结点从表示树的链表中删除
        for(i=0; i<LinkList_Length(list); i++)
        {
            TLNode* trNode = (TLNode*)LinkList_Get(list, i);
             
            if( trNode->node == node )
            {
                LinkList_Delete(list, i);
                
                free(trNode);
                
                index = i;
                
                break;
            }
        }
          
		//如果index>0,则表明他有父亲
        if( index >= 0 )
        {  
            if( parent != NULL )
            {
				//将他从他父亲的孩子链表中删除
                 for(i=0; i<LinkList_Length(parent->child); i++)
                 {
                     TLNode* trNode = (TLNode*)LinkList_Get(parent->child, i);
                     
                     if( trNode->node == node )
                     {
                         LinkList_Delete(parent->child, i);
                         
                         free(trNode);
                         
                         break;
                     }
                 }               
            }
            
			//如果他有儿子，将他的儿子们都杀死
            while( LinkList_Length(node->child) > 0 )
            {
                TLNode* trNode = (TLNode*)LinkList_Get(node->child, 0);
                
                recursive_delete(list, trNode->node);
            }
            
            LinkList_Destroy(node->child);
        
            free(node);
        }
    }
}

static int recursive_height(GTreeNode* node)
{
    int ret = 0;
    
    if( node != NULL )
    {
        int subHeight = 0;
        int i = 0;
        
        for(i=0; i<LinkList_Length(node->child); i++)
        {
            TLNode* trNode = (TLNode*)LinkList_Get(node->child, i);
            
            subHeight = recursive_height(trNode->node);
            
            if( ret < subHeight )
            {
                ret = subHeight;
            }
        }
        
        ret = ret + 1;
    }
    
    return ret;
}

static int recursive_degree(GTreeNode* node)
{
int ret = -1;
    
    if( node != NULL )
    {
        int subDegree = 0;
        int i = 0;
        
        ret = LinkList_Length(node->child);
        
        for(i=0; i<LinkList_Length(node->child); i++)
        {
            TLNode* trNode = (TLNode*)LinkList_Get(node->child, i);
            
            subDegree = recursive_degree(trNode->node);
            
            if( ret < subDegree )
            {
                ret = subDegree;
            }
        }
    }
    
    return ret;
}

GTree* GTree_Create()
{
    return LinkList_Create();
}

void GTree_Destroy(GTree* tree)
{
    GTree_Clear(tree);
    LinkList_Destroy(tree);
}

void GTree_Clear(GTree* tree)
{
     GTree_Delete(tree, 0);
}

int GTree_Insert(GTree* tree, GTreeData* data, int pPos)
{
    LinkList* list = (LinkList*)tree;  //传进被插入的树，表示的实质为链表
	//合法性判断
    int ret = (list != NULL) && (data != NULL) && (pPos < LinkList_Length(list)); //所插入的结点必须在树当中，
																				  //故而是pPos < LinkList_Length(list)
    
    if( ret )
    {
        TLNode* trNode = (TLNode*)malloc(sizeof(TLNode));    //创建一个结点，用于记录保存树的链表中的结点
        TLNode* cldNode = (TLNode*)malloc(sizeof(TLNode)); //孩子（是个链表）
        TLNode* pNode = (TLNode*)LinkList_Get(list, pPos);  //从表示树的链表中获取要插入结点父母亲
        GTreeNode* cNode = (GTreeNode*)malloc(sizeof(GTreeNode));  //要插入的结点，用于接收传进来的data
        
        ret = (trNode != NULL) && (cldNode != NULL) && (cNode != NULL); //树中结点不能为空，该结点
        
        if( ret )
        {
            cNode->data = data;     //保存数据
            cNode->parent = NULL;   //现在还弄不清他的父母亲是谁
            cNode->child = LinkList_Create();  //要插入的结点的孩子是个链表
            
            trNode->node = cNode;  //将要插入的结点赋值给表示树的链表
            cldNode->node = cNode; //将要插入的结点赋值给树结点中的孩子链表
            
            LinkList_Insert(list, (LinkListNode*)trNode, LinkList_Length(list)); //向表示树的链表中插入
            
            if( pNode != NULL )  //如果要插入的结点有父节点，就向父节点的子结点链表插入该结点
            {
                cNode->parent = pNode->node;//认亲的过程
                
				//正式加入大家庭
                LinkList_Insert(pNode->node->child, (LinkListNode*)cldNode, LinkList_Length(pNode->node->child));
            }
        }
        else
        {
            free(trNode);
            free(cldNode);
            free(cNode);
        }
    }
    
    return ret;
}

//删除结点
GTreeData* GTree_Delete(GTree* tree, int pos)
{
    TLNode* trNode = (TLNode*)LinkList_Get(tree, pos);
    GTreeData* ret = NULL;
    
    if( trNode != NULL )
    {
        ret = trNode->node->data;
        
        recursive_delete(tree, trNode->node);
    }
    
    return ret;
}

//获得指定位置的结点
GTreeData* GTree_Get(GTree* tree, int pos)
{
    TLNode* trNode = (TLNode*)LinkList_Get(tree, pos);
    GTreeData* ret = NULL;
    
    if( trNode != NULL )
    {
        ret = trNode->node->data;
    }
    
    return ret;
}

//获得根结点
GTreeData* GTree_Root(GTree* tree)
{
    return GTree_Get(tree, 0);
}


//求树的高度
int GTree_Height(GTree* tree)
{
    TLNode* trNode = (TLNode*)LinkList_Get(tree, 0);
    int ret = 0;
    
    if( trNode != NULL )
    {
        ret = recursive_height(trNode->node);
    }
    
    return ret;
}

//求树的结点个数
int GTree_Count(GTree* tree)
{
    return LinkList_Length(tree);
}

//求树的度
int GTree_Degree(GTree* tree)
{
    TLNode* trNode = (TLNode*)LinkList_Get(tree, 0);
    int ret = -1;
    
    if( trNode != NULL )
    {
        ret = recursive_degree(trNode->node);
    }
    
    return ret;
}

void GTree_Display(GTree* tree, GTree_Printf* pFunc, int gap, char div)
{
    TLNode* trNode = (TLNode*)LinkList_Get(tree, 0);
    
    if( (trNode != NULL) && (pFunc != NULL) )
    {  
        recursive_display(trNode->node, pFunc, 0, gap, div);
    }
}

主函数操作部分：

// 树.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "GTree.h"
#include <stdlib.h>

void printf_data(GTreeData* data)
{
    printf("%c", (int)data);
}
int _tmain(int argc, _TCHAR* argv[])
{

	GTree* tree = GTree_Create();
    int i = 0;
    
    GTree_Insert(tree, (GTreeData*)'A', -1);
    GTree_Insert(tree, (GTreeData*)'B', 0);
    GTree_Insert(tree, (GTreeData*)'C', 0);
    GTree_Insert(tree, (GTreeData*)'D', 0);
    GTree_Insert(tree, (GTreeData*)'E', 1);
    GTree_Insert(tree, (GTreeData*)'F', 1);
    GTree_Insert(tree, (GTreeData*)'H', 3);
    GTree_Insert(tree, (GTreeData*)'I', 3);
    GTree_Insert(tree, (GTreeData*)'J', 3);
    
    printf("Tree Height: %d\n", GTree_Height(tree));
    printf("Tree Degree: %d\n", GTree_Degree(tree));
    printf("Full Tree:\n");
    
    GTree_Display(tree, printf_data, 2, ' ');
    
    printf("Get Tree Data:\n");
    
    for(i=0; i<GTree_Count(tree); i++)
    {
        printf_data(GTree_Get(tree, i));
        printf("\n");
    }
    
    printf("Get Root Data:\n");
    
    printf_data(GTree_Root(tree));
    
    printf("\n");
    
    GTree_Delete(tree, 3);
     
    printf("After Deleting D:\n");
    
    GTree_Display(tree, printf_data, 2, '-');
    
    GTree_Clear(tree);
    
    printf("After Clearing Tree:\n");
    
    GTree_Display(tree, printf_data, 2, '.');
        
    GTree_Destroy(tree);

	system("pause");
	return 0;
}

运行结果：

Tree Height: 3
Tree Degree: 3
Full Tree:
A
  B
    E
    F
  C
  D
    H
    I
    J
Get Tree Data:
A
B
C
D
E
F
H
I
J
Get Root Data:
A
After Deleting D:
A
--B
----E
----F
--C
After Clearing Tree:
请按任意键继续. . .

如有错误，望不吝指出。

原文：http://blog.csdn.net/u010590318/article/details/36912439

内容总结

以上是互联网集市为您收集整理的树的实现与操作(C语言实现)全部内容，希望文章能够帮你解决树的实现与操作(C语言实现)所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1079823.html

来源：【匿名】

【上一篇】20165324 学习基础与C语言学习心得【下一篇】C语言MD5的源码实例详解

更多 ►

【树的实现与操作(C语言实现)】教程文章相关的互联网学习教程文章

int fibonacci(int positon){　　if(position==1||position==2){　　　　return 1;　　}　　return fibonacci(position-1)+fibonacci(position-2);}void test(){　　int result=fibonacci(5);//查看斐波那契数列中第五个数的值　　printf("%d\n",result);}原文：https://www.cnblogs.com/yyslif/p/11559855.html

C语言实现循环队列（基本操作及图示）【代码】【图】

———————————————————————————————————————————— 如果使用顺序表作为队列的话，当处于右图状态则不能继续插入新的队尾元素，否则会因为数组越界而导致程序代码被破坏。由此产生了由链表实现的循环队列，只有队列未满时才可以插入新的队尾元素。 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -...

C语言实现简单文件加密【代码】

原理：异或运算加密：#include<stdio.h> #include<stdlib.h> #include<string.h> #define KEY ‘@‘ int main(int argc, char * argv[]){FILE *fp;FILE *coded;char codedname[40];char ch;if(argc < 2){printf("param error!\n");exit(1);}if((fp = fopen(argv[1], "rb")) == NULL){printf("error when open file %s.\n", argv[1]);exit(1);}strcpy(codedname, argv[1]);strcat(codedname, ".coded");if((coded = fopen(codedname...

51系列小型操作系统精髓简单实现7 C语言版待改进

#include "STC12C5A.H" #define TIMER_RELOAD() {TL0=0x00;TH0=0xC4;}//使能T/C 初始10ms #define MAX_TASKS 2 //任务槽最大个数. unsigned char idata task_stack[MAX_TASKS][2];//任务堆栈. PC指针为16位，需2个字节task_stack[][0]L task_stack[][1]H。 unsigned char idata task_time[MAX_TASKS];//定时时间 unsigned char task_id=0; //当前活动任务号 void rtos_wait(unsigned char time) {static unsigned char i;//保存...

数据结构C语言实现----循环队列【代码】【图】

代码如下：#include<stdio.h> #include<stdlib.h>typedef char ElemType; #define MAXQUEUE 100typedef struct {ElemType *base;int front;int rear; }cycleQueue;///////////////////////////////// //创建一个循环队列 void initqueue(cycleQueue *q) {q->base = (ElemType*)malloc(sizeof(cycleQueue) * MAXQUEUE);//为循环队列申请连续空间if (!q->base){exit(0);}q->front = q->rear = 0;//初始换队首队尾位置为0 }//////////...

万年历的C语言实现

// Zeller公式确定星期几，w=y+[y/4]+[c/4]-2c+[26(m+1)/10]+d-1// y是年份取最后两位，c是世纪减1，m是月份，如果m是1月和2月，则m换成13和14，d是日期，[]表示取整，w除以7之后的余数就是星期几，如果余数为0，就是星期日#include <stdio.h>int main(){int year, month, y;printf("请输入年：\n");scanf("%d", &year);if (year < 1900){printf("年必须大于1900\n");exit(-1);}y = year;int c = y;y %= 100;c /= 100;int m;printf...

C语言实现使用静态数组实现循环队列

队列是一种先进先出的的数据结构，我们同样可以使用数组、链表等来实现。我们可以在队列的尾部进行插入元素，在队列的头部取出元素。普通的队列由于空间利用率不高，所以我们一般都用循环队列。循环队列中最重要的的两个操作就是判断是否为空和是否已满。当head==tail时，表示队列为空。当(tail+1)%MAX_SIZE == head，表示队列已满。我判断队满的方法：牺牲一个单元来区分对空和队满，入队时少用一个队列单元，相当于浪费一...

用C语言实现，输入圆的半径，输出圆的面积和周长【代码】【图】

#include <stdio.h>/**要求：输入圆的半径，输出圆的面积和周长 */int main(void) {/**声明一个float类型的变量 radius 来获取半径的值；area来表示面积，perimeter来表示周长*/float radius;float area;float perimeter;printf("----输入半径以计算圆的面积和周长----\n");printf("请输入圆的半径:");scanf("%f",&radius);//计算圆的面积area = 3.1415926*(radius*radius);//计算圆的周长perimeter = 2*radius*3.1415926;printf("...

c语言实现bit反转的最佳算法-从msb-lsb到lsb-msb【代码】

问题实现如下转换的最佳算法是什么？0010 0000 => 0000 0100 具体的转换是从MSB->LSB到LSB->MSB, 所有的Bit都必须反转，那意味着，这并不是字节顺序的交换。最佳答案注意: 下面的算法都用C实现，但应该可以迁移到其它语言(只是不那么快的时候可别找我)。可选方案内存占用少(32位int，32位机器)(来源于这里)unsigned int reverse(register unsigned int x) {x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));x = (((x & 0x...

算法导论学习---红黑树详解之插入(C语言实现)【代码】【图】

前面我们学习二叉搜索树的时候发现在一些情况下其高度不是很均匀，甚至有时候会退化成一条长链,所以我们引用一些”平衡”的二叉搜索树。红黑树就是一种”平衡”的二叉搜索树，它通过在每个结点附加颜色位和路径上的一些约束条件可以保证在最坏的情况下基本动态集合操作的时间复杂度为O(nlgn).下面会总结红黑树的性质，然后分析红黑树的插入操作，并给出一份完整代码。先给出红黑树的结点定义：#define RED 1#define BLACK 0///红黑...

二叉树顺序结构实现的C语言【图】

#include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h"#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define MAXSIZE 100 /* 存储空间初始分配量 */#define MAX_TREE_SIZE 100 /* 二叉树的最大结点数 */typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */typedef int TElemType; /* 树结点的数据类型，目前暂定为整型 */typedef TElemType ...

C语言实现链表节点的插入

对链表进行增删改查是最基本的操作。我在上一篇博客《C语言实现链表节点的删除》实现了删除链表中的某个节点。这里我们要来实现在某个位置插入节点。示例代码上传至https://github.com/chenyufeng1991/InsertList 。核心代码如下：Node *InsertToPosition(Node *pNode,int pos,int x){if (pos < 0 || pos > sizeList(pNode) ) {printf("%s函数执行，pos=%d非法，插入数据失败\n",__FUNCTION__,pos);return pNode;}Node *pMove;Nod...

C语言实现对文本文件的操作【代码】

这几天做东西用到了文件的读取简单的整理了下需要的头文件是：#include <stdio.h>1.需要打开文件：用fopen_s(FILE ** _File,const char * _Filename,const char * _Mode);也可以用fopen函数参数类型一样，fopen_s比fopen多了些安全机制，后面的函数都可以使用函数_s，eg:fprintf_s(FILE * _File, const char * _Format, ...);2.写入数据到文件：fprintf(FILE * _File, const char * _Format, ...);第一个就是文件，后面的和printf...

【c语言】不用库函数实现strcmp

// 不用库函数实现strcmp#include <stdio.h> #include <assert.h>int my_strcmp( char const *p,char const *q ) {assert( ( *p != NULL ) && ( *q != NULL ) );while( *p == *q ){if( *p == '\0'){return 0;}p++;q++;}if( *p > *q ){return 1;}else{return -1;}}int main() {char *p = "aebh";char *q = "addfg";printf("%d\n",my_strcmp( p,q ));return 0; }<img src="http://img.blog.csdn.net/20150330230907026?watermark/2/t...

POS终端MAC算法－C语言实现

POS终端MAC算法－C语言实现原文：http://www.cnblogs.com/LittleTiger/p/6388813.html

C语言 - 技术教程分类

C 语言教程 C 简介 C 程序结构 C 基本语法 C 数据类型 C 变量 C 常量 C 存储类 C 运算符 C 判断 C 循环 C 函数 C 作用域规则 C 数组 C enum(枚举) C 指针 C 函数指针与回调函数 C 字符串 C 结构体 C 共用体 C 位域 C typedef C 输入 & 输出 C 文件读写 C 头文件 C 强制类型转换 C 错误处理 C 递归 C 可变参数 C 内存管理 C 命令行参数 C 语言实例 C 标准库 -?ctype.h C 标准库 -?math.h C 标准库 -?stdlib.h C 标准库 -?string.h c语言全部

C语言 - 最热教程

C语言调试器GDB和LLDB的使用方法 C语言连接MySQL数据库（课程设计总结）小白入门C语言之数组篇 C/C++编程笔记：Unix AIX和Linux C语言...C语言打印Hello sublime text 3 编译C语言配置 C语言编程快捷键线索二叉树（C语言）C语言输出系统时间 c语言小游戏-三子棋的完成

首页 / C语言 / 树的实现与操作(C语言实现)

树的实现与操作(C语言实现)

内容导读

内容图文

内容总结

内容备注

内容手机端

【树的实现与操作(C语言实现)】教程文章相关的互联网学习教程文章

斐波那契数列的实现（C语言）

C语言实现循环队列（基本操作及图示）【代码】【图】

C语言实现简单文件加密【代码】

51系列小型操作系统精髓简单实现7 C语言版待改进

数据结构C语言实现----循环队列【代码】【图】

万年历的C语言实现

C语言实现使用静态数组实现循环队列

用C语言实现，输入圆的半径，输出圆的面积和周长【代码】【图】

c语言实现bit反转的最佳算法-从msb-lsb到lsb-msb【代码】

算法导论学习---红黑树详解之插入(C语言实现)【代码】【图】

二叉树顺序结构实现的C语言【图】

C语言实现链表节点的插入

C语言实现对文本文件的操作【代码】

【c语言】不用库函数实现strcmp

POS终端MAC算法－C语言实现

C语言 - 相关标签

C语言 - 技术教程分类

C语言 - 最新教程

C语言 - 最热教程