st.pop（）;
}
return0;
}
6）链表的逆序实现
Node*ReverseLink（Node*head）
{
Node*prev=NULL;
Node*next;
while（head!
=NULL）
{
next=head->next;
head->next=prev;
prev=head;
head=next;
}
returnprev;
}
4.要及时释放内存空间，malloc（）和free（）两个函数要配合使用。
3.栈
1）定义：
先进后出,限定只能在表的一端进行插入和删除操作的线性表;
2）线性表分类：
1>顺序线性表（也就是用数组实现的,在内存中顺序排列,通过改变数组序号来实现压栈和出栈）
a.定义一个结构体,保存栈的基本信息
typedefstructsqStack
{
intsize;
int*sp;
int*top;
}sqStack;
b.栈初始化，定义栈的大小和指针
intstackInit（sqStacks）
{
s->top=（int*）malloc（sizeof（int）*n）;
s->sp=s->top;
}
c.压栈
intpush（sqStack*s,intval）
{
s->val=val;
s->sp++;
return0;
}
d.出栈
intpop（sqStack*s）
{
intval=0;
s->sp--;
val=s->val;
returnval;
}
2>链表（主要是对链表表头进行操作）
a.定义一个结构体,作为栈的节点
typedefstructsqStack
{
intval;
structsqStack*next;
}sqStack;
b.栈初始化
sqStack*stackInit（）
{
sqStack*s;
returns;
}
c.压栈
sqStack*push（sqStack*s,intval）
{
sqStack*nod=NULL;
nod=（sqStack*）malloc（sizeof（sqStack））;
if（nod==NULL）
{
returnNULL;
}
nod->val=val;
nod->next=s;
s=nod;
returns;
}
d.出栈
sqStack*pop（sqStack*s）
{
sqStack*nod=NULL;
intval=0;
val=s->val;
nod=s;
s=s->next;
free（nod）;
returnval;
}
3>栈的实现：
可以采用两种方式，可以分别采用顺序表或者链表实现。
4>应用：
a.四则运算
b.符号检测
4.队列
1）定义：
先进先出,限定只能在表的一端进行插入和在另一端进行删除操作的线性表;
2）队列的实现：
可以采用两种方式，可以分别采用顺序表或者链表实现。
3）应用：
5.二叉树
1）基本概念：
1>定义：
每个结点最多有两棵子树，左子树和右子树，次序不可以颠倒
2>性质：
a.非空二叉树的第n层上至多有2^（n-1）个元素
b.深度为h的二叉树至多有2^h-1个结点
3>其他概念：
a.满二叉树：
b.完全二叉树：
2）存储结构
1>顺序存储：
将数据结构存在一块固定的数组中
#defineLENGTH100
typedefchardatatype;
typedefstructnode
{
datatypedata;
intlchild,rchild;
intparent;
}Node;
Nodetree[LENGTH];
intlength;
introot;
2>链式存储：
typedefchardatatype;
typedefstructBinNode
{
datatypedata;
structBinNode*lchild;
structBinNode*rchild;
}BinNode;
typedefBinNode*bintree; //bintree本身是个指向结点的指针
3）二叉树的遍历
1>前序遍历：
根节点->左子树->右子树
2>中序遍历：
左子树->根节点->右子树
3>后序遍历：
左子树->右子树->根节点
4）遍历的实现
1>递归实现
1>二叉树的创建
a.创建二叉树节点
typedefstructBiTree
{
charchr;
structBiTree*lchild;
structBiTree*rchild;
}BiTree;
b.创建二叉树
BiTree*CreateBiTree（）
{
charchr;
BiTree*T=NULL;
scanf（"%c",&chr）;
if（chr!
=''）
{
T=（BiTree*）malloc（sizeof（BiTree））;
if（T==NULL）
{
printf（"Memoryisfailed!
\n"）;
returnNULL;
}
T->chr=chr;
T->lchild=CreateBiTree（）;
T->rchild=CreateBiTree（）;
}
returnT;
}
2>前序遍历
intpreOlderTraverse（BiTree*T）
{
if（T）
{
printf（"%c",T->chr）;
preOlderTraverse（T->lchild）;
preOlderTraverse（T->rchild）;
}
return0;
}
3>中序遍历
intinOlderTraverse（BiTree*T）
{
if（T）
{
inOlderTraverse（T->lchild）;
printf（"%c",T->chr）;
inOlderTraverse（T->rchild）;
}
return0;
}
4>后序遍历
intpostOlderTraverse（BiTree*T）
{
if（T）
{
postOlderTraverse（T->lchild）;
postOlderTraverse（T->rchild）;
printf（"%c",T->chr）;
}
return0;
}
2>非递归实现
1>创建堆栈
a.创建节点
typedefstructsqStack
{
BiTree*Bt;
structsqStack*sp;
}sqStack;
b.push（）函数实现
intpush（sqStack**S,BiTree*Bt）
{
sqStack*Stack=NULL;
Stack=（sqStack*）malloc（sizeof（sqStack））;
if（Stack==NULL）
{
printf（"Memoryisfailed!
\n"）;
return0;
}
Stack->Bt=Bt;
Stack->Bt->lchild=Bt->lchild;
Stack->Bt->rchild=Bt->rchild;
Stack->sp=（*S）;
（*S）=Stack;
return0;
}
c.pop（）函数实现
BiTree*pop（sqStack**S）
{
BiTree*Bt=NULL;
sqStack*Stack=NULL;
Bt=（*S）->Bt;
Stack=（*S）;
（*S）=（*S）->sp;
free（Stack）;
returnBt;
}
2>二叉树的创建
a.创建二叉树节点
typedefstructBiTree
{
charchr;
structBiTree*lchild;
structBiTree*rchild;
}BiTree;
b.创建二叉树
BiTree*CreateBiTree（）
{
BiTree*T=NULL;
charchr;
scanf（"%c",&chr）;
if（chr!
='#'）
{
T=（BiTree*）malloc（sizeof（BiTree））;
if（T==NULL）
{
printf（"Memroyisfailed!
\n"）;
returnNULL;
}
T->chr=chr;
T->lchild=CreateBiTree（）;
T->rchild=CreateBiTree（）;
}
returnT;
}
3>前序遍历
intpreOlderVisitBiTree（sqStack*S,BiTree*T）
{
if（!
T）
{
printf（"TheBiTreeisempty!
\n"）;
}
else
{
while（T||S）
{
while（T）
{
printf（"%c",T->chr）;
push（&S,T）;
T=T->lchild;
}
T=pop（&S）;
T=T->rchild;
}
}
return0;
}
4>中序遍历
intinOlderVisitBiTree（sqStack*S,BiTree*T）
{
if（!
T）
{
printf（"TheBiTreeisempty!
\n"）;
}
else
{
while（T||S）
{
while（T）
升级会员 