计算机基础-数据结构（c语言版）

概述

1976 年瑞士计算机科学家尼克劳斯•维尔特（Niklaus Wirth）曾提出一个著名公式： 算
法+数据结构=程序。
数据 所有被计算机存储、处理的对象。
数据元素 数据的基本单位，是运算的基本单位。常常又简称为元素。
数据项 是数据的不可分割的最小标识单位。在数据库中数据项又称为字段或域。
从宏观上看，数据、数据元素和数据项实际上反映了数据组织的三个层次，数据可由若干个
数据元素组成，而数据元素又可由若干个数据项组成。
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。它包括数据的逻辑结构、
数据的存储结构和数据的基本运算。
1、数据的逻辑结构：指数据元素之间的逻辑关系。所谓逻辑关系是指数据元素之间的关联
方式或“邻接关系”。
2、四类基本的逻辑结构：
集合 任意两个结点之间都没有邻接关系，组织形式松散。
线性结构 结点按逻辑关系依次排列形成一条“链”，结点之间一个一个依次相邻接。
树形结构 具有分支、层次特性，其形态像自然界中的树，上层的结点可以和下层多个结
点相邻接，但下层结点只能和上层的一个结点相邻接。
图结构 最复杂，其中任何两个结点都可以相邻接。

数据的存储结构☆☆

1、数据的逻辑结构在计算机中的实现称为数据的存储结构（或物理结构）。
2、表示数据元素之间的关联方式：
顺 序 存
储方式
指所有存储结点存放在一个连续的存储区里。利用结点在存储器中的相对位置来
表示数据元素之间的逻辑关系。
链 式 存
储方式
指每个存储结点除了含有一个数据元素外，还包含指针，每个指针指向一个与本
结点有逻辑关系的结点，用指针表示数据元素之间的逻辑关系。
关系：一种逻辑结构可以采用一种或几种存储方式来表达数据元素之间的逻辑关系，相应的
存储结构称为给定逻辑结构的存储实现或存储映像。
4
四、运算☆
1、运算：指在某种逻辑结构上施加的操作，即对逻辑结构的加工。
2、线性表、栈和队列中的元素具有相同的逻辑结构（即线性结构），但有不同的运算集，
它们是不同的数据结构。

第三节 算法及描述

运算的实现是指该运算的算法。

第四节 算法分析☆☆

评价算法好坏的因素：☆☆
正确性 能正确地实现预定的功能，满足具体问题的需要。
易读性 易于阅读、理解和交流，便于调试、修改和扩充。
健壮性 即使输入非法数据，算法也能适当地做出反应或进行处理，不会产生预料不到的
运行结果。
时空性 一个算法的时空性是指该算法的时间性能（或时间效率）和空间性能（或空间效
率）， 前者是算法包含的计算量，后者是算法需要的存储量。

一、时间复杂度☆☆
1、大 O 表示法。T(n) =O(f(n))称为算法的渐进时间复杂度，简称时间复杂度。

2、时间复杂度常见的阶数：
(1) 常数阶 O(1)（即算法的时间复杂度与输入规模 n 无关）；
(2) 对数阶 O(log2n)；
(3) 线性阶 O(n)；
(4) 多项式阶 O(nC)，C 为大于 1 的正整数，常见的多项式阶有 O(n2)和 O(n3)；
(5) 指数阶 0 (Cn)，C 为大于 1 的正整数，常见的指数阶有 O(2n)。

二、空间复杂度☆☆
空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。

存储空间量应包括：
（1）程序代码所占用的空间；
（2）输入数据所占用的空间；
（3）辅助变量所占用的空间，估算时，一般只需要分析辅助变量所占用的空间。

【习题演练】
1、数据的不可分割的最小标识单位是（）
A:数据项 B:数据记录
5
C:数据元素 D:数据变量
答案：A
解析：一般情况下，数据元素由数据项组成。在数据库中数据项又称为字段或域。它是数据
的不可分割的最小标识单位。
2、具有分支、层次特性，上层的结点可以和下层多个结点相邻接，但下层结点只能和上层
的一个结点相邻接，这种组织形式称为（）
A:集合 B:线性结构
C:树形结构 D:图结构
答案：C
解析：树形结构具有分支层次特性，其形态像自然界的树，上层的结点可以和下层多个结点
相邻接，但下层结点只能和上层的一个结点相邻接。

线性表

第一节 线性表的基本概念

概念 线性表是一种线性结构，它是由 n(n≥0)个数据元素组成的有穷序列，数据元素
又称结点。结点个数 n 称为表长。
基 本 特
征
线性表中结点具有一对一的关系，如果结点数不为零，则除起始结点没有直接前
驱外，其他每个结点有且仅有一个直接前驱；除终端结点没有直接后继外，其他
每个结点有且仅有一个直接后继。
基 本 运
算 及 功
能描述
(1) 初始化 Initiate (L)：建立一个空表 L=()，L 不含数据元素。
(2) 求表长 Length(L)：返回线性表 L 的长度。
(3) 读表元素 Get (L，i)：返回线性表第 i 个数据元素，当 i 不满足 1≤i≤Length(L)
时，返回一特殊值。
(4) 定位 Locate(L，x)：查找线性表中数据元素值等于 x 的结点序号，若有多
个数据元素值与 x 相等，运算结果为这些结点中序号的最小值，若找不到该
结点，则运算结果为 0。
(5) 插入 Insert(L，x，i)：在线性表 L 的第 i 个数据元素之前插入一个值为 x 的
新数据元素，参数 i 的合法取值范围是 1≤i≤n+1。
(6) 删除 Delete (L，i)：删除线性表 L 的第 i 个数据元素 ai，i 的有效取值范围
是 1≤i≤n。

第二节 线性表的顺序存储

一、线性表顺序存储的类型定义
用顺序存储实现的线性表称为顺序表。一般使用数组来表示顺序表。

二、线性表的基本运算在顺序表上的实现☆☆☆☆
顺序表的“第 i 个数据元素”存放在数组下标为“i-1”的位置。
1、插入
顺序表的插入运算 InsertSeqlist (SeqList L,DataType x,int i)是指在顺序表的第 i(1≤i≤
n+1)个元素之前，插入一个新元素 x。使长度为 n 的线性表（a1，a2，…，ai-1，ai，ai+1，.…，
an)变为长度为 n+1 的线性表(a1，a2，…，ai-1，x， ai，ai+1，.…，an)。
插入算法的基本步骤是：首先将结点 ai~an 依次向后移动一个元素的位置，这样空出第 i
个数据元素的位置；然后将 x 置入该空位，最后表长加 1。所需移动元素的个数为 n-i+1。
具体的插入算法描述如下：
void InsertSeqlist(SeqList L,DataType x, int i)
{ //将元素 x 插入到顺序表 L 的第 i 个数据元素之前
if (L. length==Maxsize) exit(“表已满”);
if (i<1 || i>L. length+1) exit(“位置错”)；//检查插入位置是否合法
for(j=L.length;j>=i;j–) //初始 i=L.length
L.data[j]=L.data[j-1]; //依次后移
L.data[i-1]=x; //元素 x 置入到下标为 i-1 的位置
L.length++; //表长度加 1
}
2、删除
删除运算 DeleteSeqlist(SeqList L,int i)是指将线性表的第 i(1≤i≤n)个数据元素删去，使长
度为 n 的线性表（a1，a2，…，ai-1， ai，ai+1，.…，an)变为长度为 n-1 的线性表(a1，
a2，…，ai-1，ai+1，.…，an)。
删除运算的基本步骤是：①结点 ai+1,…，an 依次向左移动一个元素位置（从而覆盖掉被删
结点 ai）；②表长度减 1。此处无需考虑溢出，只判断参数 i 是否合法即可。所需移动元素
的个数为 n-i。
算法描述如下：
void DeleteSeqList(SeqList L,int i) {
//删除线性表 L 中的第 i 个数据结点
if(i<1 || i>L.length) //检查位置是否合法
exit(“非法位置”);
for(j=i;j<L.length;j ++) //第 i 个元素的下标为 i-1
L.data[j-1]=L.data[j]; //依次左移
L.length–; //表长度减 1
}
7
3、定位
定位运算 LocateSeqlist(SeqList L,DataType x)的功能是查找出线性表 L 中值等于 x 的结点
序号的最小值，当找不到值为 x 的结点时，返回结果 0。
三、顺序表实现算法的分析☆☆
（1）设表的长度 length=n，在插入算法中，元素的移动次数不仅与顺序表的长度 n 有关，
还与插入的位置 i 有关。一般情况下元素比较和移动的次数为 n-i+1 次，插入算法的平均移
动次数约为 n/2，其时间复杂度是 O(n)。
（2）删除算法：时间复杂度为 O(n)，元素平均移动次数约为（n-1）/2，时间复杂度为
O(n)。
（3）定位算法：以参数 x 与表中结点值的比较为标准操作，平均时间复杂度为 O(n)。求表
长和读表元素算法的时间复杂度为 O(1)，就阶数而言，己达到最低。

第三节 线性表的链接存储

一、单链表的类型定义☆☆
1、结点结构
（1）data 部分称为数据域，用于存储线性表的一个数据元素。
（2）next 部分称为指针域或链域，用于存放一个指针，该指针指向本结点所含数据元素的
直接后继结点。
2、单链表：所有结点通过指针链接形成链表。
（1）head 称为头指针变量，该变量的值是指向单链表的第一个结点的指针。可以用头指
针变量来命名单链表。
（2）链表中第一个数据元素结点称为链表的首结点。
（3）链表中最后一个数据元素结点称为尾结点或终端结点。尾结点指针域的值 NULL 称为
空指针，它不指向任何结点，表示链表结束。
3、单链表的类型定义如下：☆☆☆☆
typedef struct node
{ DataType data; //数据域
struct node * next; //指针域
}Node, LinkList;
4、带头结点的单链表
在单链表的第一个结点之前增设一个类型相同的结点，称之为头结点，其他结点称为表结点。
表结点的第一个和最后一个结点分别就是首结点和尾结点。
二、线性表的基本运算在单链表上的实现
1、求表长☆☆
在单链表存储结构中，线性表的表长等于单链表中数据元素的结点个数，即除了头结点以外
的结点的个数。
设置一个工作指针 p，初始时，p 指向头结点，并设置一个计数器 cnt，初值设置为 0。然
后，让工作指针 p 通过指针域逐个结点向尾结点移动，工作指针每向尾部移动一个结点，
8
让计数器加 1。直到工作指针 p->next 为 NULL 时，说明已经走到了表的尾部，这时已完
成对所有结点的访问，计数器 cut 的值即是表的长度。
2、定位☆☆☆
线性表的定位运算，就是对给定表元素的值，找出这个元素的位置。在单链表的实现中，则
是给定一个结点的值，找出这个结点是单链表的第几个结点。定位运算又称作按值查找。
在定位运算中，也需要从头至尾访问链表，直至找到需要的结点，返回其序号。若未找到，
返回 0。
3、插入☆☆☆☆
单链表的插入运算是将给定值为 x 的元素插入到链表 head 的第 i 个结点之前。
步骤：（1）先找到链表的第 i-1 个结点 q。（2）生成一个值为 x 的新结点 p，p 的指针域
指向 q 的直接后继结点。（3）q 的指针域指向 P。
插入运算描述如下：
void InsertLinklist (LinkList head, DataType x, int i)
//在表 head 的第 i 个数据元素结点之前插入一个以 x 为值的新结点
{
Node p,q;
if (i1) q=head;
else q=GetLinklist (head, i-1); //找第 i-1 个数据元素结点
if (qNULL) //第 i-1 个结点不存在
exit(“找不到插入的位置”);
else
{
p=malloc(sizeof (Node) );p->data=x; //生成新结点
p->next=q->next; //新结点链域指向q 的后继结点
q->next=p; //修改q 的链域
}
}
链接操作 p->next=q->next 和 q->next=p 两条语句的执行顺序不能颠倒，否则结点q
的链域值（即指向原表第 i 个结点的指针）将丢失。
4、删除☆☆☆
删除运算是给定一个值 i，将链表中第 i 个结点从链表中移出，并修改相关结点的指针域，
以维持剩余结点的链接关系。如下图，将 ai 结点移出后，需要修改该结点的直接前驱结点
的指针域，使其指向移出结点 ai 的直接后继结点。

第四节 其他链表

一、循环链表☆☆
在单链表中，如果让最后一个结点的指针域指向第一个结点可以构成循环链表。
9
二、双向循环链表☆☆
1、结点结构
在单链表的每个结点中再设置一个指向其直接前驱结点的指针域 prior，这样每个结点有两
个指针，其结点结构如图：
2、双向循环链表的概念
prior 与 next 类型相同，它指向直接前驱结点。头结点的 prior 指向最后一个结点，最后一
个结点的 next 指向头结点，由这种结点构成的链表称为双向循环链表。
3、删除
设 p 指向待删结点，删除p 可通过下述语句完成：
(1) p->prior->next=p->next; //p 前驱结点的后链指向 p 的后继结点
(2) p->next->prior=p->prior; //p 后继结点的前链指向 p 的前驱结点
(3) free§; //释放p 的空间
（1）、（2）这两个语句的执行顺序可以颠倒。
4、插入
在 p 所指结点的后面插入一个新结点*t，需要修改四个指针:
(1) t->prior=p;
(2) t->next=p->next;
(3) p->next->prior=t;
(4) p->next=t;
第五节 顺序实现与链接实现的比较☆
（1）对于按位置查找运算，顺序表是随机存取，时间复杂度为 O(1)。单链表需要对表元 素
进行扫描，它时间为复杂度为 O(n)。
（2）对于定位运算，基本操作是比较，顺序表和单链表上的实现算法的时间复杂度都是相
同的，均为 O(n)。
（3）对于插入、删除运算。在顺序表中，平均时间复杂度为 O(n)。在单链表中，其平均时
间复杂度仍然为 O(n)。
【习题演练】
1、设顺序表的表长为 10，则执行插入算法的元素平均移动次数约为（）
A:4 B:5
C:6 D:7
答案：B
解析：设顺序表的长度为 n，插入算法的平均移动次数约为 n/2。
2、在单链表中，存储每个结点需要有两个域，一个是数据域，另一个是指针域，指针域指
向该结点的（）
A:直接前趋 B:直接后继
10
C:开始结点 D:终端结点
答案：B
解析：一个数据元素和一个指针组成单链表的一个结点。data 部分称为数据域，用于存储
线性表的一个数据元素，next 部分称为指针域或链域,用于存放一个指针，该指针指向本结
点所含数据元素的直接后继结点

第三章 队列和数组

第零节 队列和数组☆
栈和队列可看作是特殊的线性表。它们的特殊性表现在它们的基本运算是线性表运算的子
集，它们是运算受限的线性表。

第一节 栈

一、栈的基本概念☆☆
1、栈：这种线性表上的插入和删除运算限定在表的某一端进行。允许进行插入和删除的一
端称为栈顶，另一端称为栈底。不含任何数据元素的栈称为空栈。处于栈顶位置的数据元素
称为栈顶元素。
2、栈的修改原则是后进先出，栈又称为后进先出线性表，简称后进先出表。栈的插入和删
除运算分别称为进栈和出栈。
3、栈的基本运算：☆☆☆☆
(1) 初始化 InitStack(S)：构造一个空栈 S；
(2) 判栈空 EmptyStack(S)：若栈 S 为空栈，则结果为 1，否则结果为 0；
(3) 进栈 Push(S, x)：将元素 x 插入栈 S 中，使 x 成为栈 S 的栈顶元素；
(4) 出栈 Pop(S)：删除栈顶元素；
(5) 取栈顶 GetTop(S)：返回栈顶元素。
二、栈的顺序实现☆☆
①当空栈，栈顶下标值 top=0，如果此时做出栈运算，则产生“下溢”。
②当栈中的数据元素已经填满了，如果再进行进桟操作，会发生“上溢”。
基本运算 描述
初始化 int InitStack(SeqStk *stk)
{
stk->top=0;
return 1;
}
判栈空 int EmptyStack(SeqStk *stk)
11
//若栈为空，则返回值 1，否则返回值 0
{
if (stk->top0)
return 1;
else return 0;
}
进栈 int Push(SeqStk *stk, DataType x)
//若栈未满，元素 x 进栈 stk 中，否则提示出错信息
{
if (stk->topmaxsize-1) //判断找是否满
{ error (“栈已满”);
return0;
}
else
{ stk->top++; //栈未满，top 值加 1
stk->data[stk->top]=x; //元素 x 进桟
return 1;
}
}
出栈 int Pop {SeqStk *stk)
{ if (EmptyStack(stk)) //判断是否下溢（栈空）
{ error(“下溢”);
return 0;
}
else //未下溢，栈顶元素出栈
{ stk->top–; //top 值减 1
return 1;
}
}
取栈顶元
素
DataType GetTop(SeqStk *stk)
//取栈顶数据元素,栈顶数据元素逋过参数返回
{ if (EmptyStack(stk)) return NULLData; //栈空，返回 NULLData
else
return stk->data[stk->top]; //返回栈顶数据元素
}
12
三、栈的链接实现☆☆
基本运算 描述
进栈 void Push (LkStk *LS, DataType x)
{ LkStk *temp;
temp=(LkStk *)malloc(sizeof(LkStk)); //temp 指向申请的新结点
temp->data=x; //新结点的 data 域赋值为 x
temp->next=LS->next; //temp 的 next 域指向原来的栈顶结点
LS->next=temp; //指向新的找顶结点
}
出栈 int Pop(LkStk *LS)
//栈顶数据元素通过参数返回，它的直接后继成为新的栈顶
{ LkStk *temp;
if (!EmptyStack(LS)) //判断栈是否为空
{ temp=LS->next; //temp 指向栈顶结点
LS->next=temp->next; //原栈顶的下一个结点成为新的栈顶
free(temp); //释放原栈顶结点空间
return 1;
}
else return 0；
}

第二节 队列

一、队列的基本概念☆☆☆
概念 是有限个同类型数据元素的线性序列，是一种先进先出的线性表。
基本
运算
(1) 队列初始化 InitQueue(Q)：设置一个空队列 Q；
(2) 判队列空 EmptyQueue(Q)：若队列 Q 为空，则返回值为 1，否则返回值为 0；
(3) 入队列 EnQUeUe(Q，x)：将数据元素 x 从队尾一端插入队列，使其成为队列
的新尾元素；
(4) 出队列 OutQueue(Q)：删除队列首元素；
(5) 取队列首元素 GetHead(Q)：返回队列首元素的值。
二、队列的顺序实现☆☆
顺序队列 顺序存储实现的队列称为顺序队列，顺序队列结构类型中有三个域：data、
front 和 rear。
入队列赋值语句：SQ.rear=SQ.rear+1; SQ.data[SQ.rear]=x 完成。
出队列赋值语句：SQ.frontSQ.front+1 完成。会出现“假溢出”现象。
循环队列 为了避免元素的移动，将存储队列元素的一维数组首尾相接，形成一个环状。
入队列操作语句：SQ.rear=(SQ.rear+1) % maxsize; SQ.data[SQ.rear]=x;
出队列赋值语句：SQ.fronts(SQ.front+1)% maxsize;
13
循环队列满：（（CQ.rear+1）% maxsizeCQ.front）成立。
队列空条件：（CQ.rearCQ.front）成立。
三、 队列的链接实现☆
队列的链接实现实际上是使用一个带有头结点的单链表来表示队列，称为链队列。头指针指
向链表的头结点，单链表的头结点的 next 域指向队列首结点，尾指针指向队列尾结点，即
单链表的最后一个结点。
由于链接实现需要动态申请空间，故链队列在一定范围内不会出现队列满的情况，当
（LQ.frontLQ.rear）成立时，队列中无数据元素，此时队列为空。

第三节 数组

一、数组的逻辑结构和基本运算
一维数组又称向量，它由一组具有相同类型的数据元素组成，并存储在一组连续的存储单元
中。若一维数组中的数据元素又是一维数组结构，则称为二维数组。
二、数组的存储结构☆☆
1、一维数组元素的内存单元地址是连续的，二维数组可有两种存储方法：一种是以列序为
主序的存储；另一种是以行序为主序的存储（常用）。
2、数组元素的存储位置是下标的线性函数：
对于二维数组 a[m][n],如果每个元素占 k 个存储单元，以行为主序为例，讨论数组元素 a[i]
[j]位置与下标的关系。
由于下标从 0 开始，元素 a[i] [j]之前已经有 i 行元素，每行有 n 个元素，在第 i 行, 有 j+1
个元素，总共有 ni+j+1 个元素，第一个元素与 a[i] [j]相差 ni+j+1—1 个位置， 故 a[i]
[j]的位置为：loc[i, j]=loc[0,0]+(n*i+j)k。
三、矩阵的压缩存储☆☆☆☆
如果值相同的元素或者零元素在矩阵中的分布有一定规律，称此类矩阵为特殊矩阵。
矩阵的非零元素个数很少的矩阵称为稀疏矩阵。
1、特殊矩阵
（1）对称矩阵。若一个 n 阶方阵 A 中的元素满足下述条件：aij=aji 0≤i，j≤n-1，则 A
称为对称矩阵。假设以一维数组 M[n(n+1)/2]作为 n 阶对称矩阵 A 的存储结构。
（2）三角矩阵
以主对角线为界的上(下)半部分是一个固定的值 c 或零，这样的矩阵叫做下(上)三角矩阵。
14
2、稀疏矩阵
假设 m 行 n 列的矩阵有 t 个非零元素，当 t＜＜mn 时，则称矩阵为稀疏矩阵。
稀疏矩阵压缩存储的三元组表示法：
用三个项来表示稀疏矩阵中的非零元素 aij，即（i， j，aij)，其中 i 表示行序号，j 表示列序
号，aij 是非零元素的值，通常称为三元组。将稀疏矩阵中的所有非零元素用这种三元组的
形式表示，并按照一定的次序组织在一起，就形成了三元组表示法。
【习题演练】
1、在栈中进行插入和删除操作的一端称为（）
A:栈顶 B:栈底
C:任意位置 D:指定位置
答案：A
解析：允许进行插入和删除的一端称为栈顶，另一端称为栈底。
2、栈的运算特点是先进后出，元素 a、b、c、d 依次入栈，则不能得到的出栈序列是（）
A:abcd B:dcba
C:cabd D:bcda
答案：C
解析：选项 C 中， 若要 c 先出栈， 则 a、 b 都要先入栈， 所以 c 出栈后 b 在 a 的
上面， 不可能 a 先出栈。

第四章 树和二叉树

第一节 树的基本概念

一、树的概念☆
1、树是 n(n 多 0)个结点的有限集合，一棵树满足以下两个条件：
（1）当 n=0 时，称为空树；
（2）当 n>0 时，有且仅有一个称为根的结点，除根结点外，真余结点分 m(m≥0)个互不
相交的非空集合 T1，T2，…，Tm，这些集合中的每一个都是一棵树，称为根的子树。

2、森林（Forest）是 m(m>0)棵互不相交的树的集合。树的每个结点的子树是森林。删除
一个非空树的根结点，它的子树便构成森林。

二、树的相关术语☆☆
(1) 结点的度：树上任一结点所拥有的子树的数目称为该结点的度。
(2) 叶子：度为 0 的结点称为叶子或终端结点。
(3) 树的度：一棵树中所有结点的度的最大值称为该树的度。
(4) 一个结点的子树的根称为该结点的孩子（或称子结点）。相应地该结点称为孩子的双亲
（也称父结点）。
(5) 结点的层次：从根开始算起，根的层次为 1,其余结点的层次为其双亲的层次加 1。
(6) 树的高度：一棵树中所有结点层次数的最大值称为该树的高度或深度。
(7) 有序树：若树中各结点的子树从左到右是有次序的，不能互换，称为有序树。有序树中
最左边子树的根称为第 1 个孩子，左边第 i 个子树的根称为第 i 个孩子。
(8) 无序树：若树中各结点的子树是无次序的，可以互换，则称为无序树。

第二节 二叉树

一、二叉树的基本概念
1、二叉树（Binary Tree）是 n(n≥0)个元素的有限集合，该集合或者为空，或者由一个根
及两棵互不相交的左子树和右子树组成，其中左子树和右子树也均为二叉树。
注意：左右子树不可换位置，都可为空。

2、二叉树的基本运算包括：
(1) 初始化 Initiate(BT)：建立一棵空二叉树，BT=0。
(2) 求双亲 Parent(BT, X)：求出二叉树 BT 上结点 X 的双亲结点，若 X 是 BT 的根或 X 根本
不是 BT 上的结点，运算结果为 NULL。
(3) 求左孩子 Lchild(BT，X)和求右孩子 Rchild(BT，X)：分别求出二叉树 BT 上结点 X 的左、
右孩子；若 X 为 BT 的叶子或 X 不在 BT 上，运算结果为 NULL。
(4) 建二叉树 Create (BT)：建立一棵二叉树 BT。
(5) 先序遍历 PreOrder(BT)：按先序对二叉树 BT 进行遍历，每个结点被访问一次且仅被
访问一次，若 BT 为空，则运算为空操作。
(6) 中序遍历 InOrde