数据结构知识点整理清华大学出版社Word格式.docx
《数据结构知识点整理清华大学出版社Word格式.docx》由会员分享，可在线阅读，更多相关《数据结构知识点整理清华大学出版社Word格式.docx（28页珍藏版）》请在冰豆网上搜索。
//存储空间基址
intlength;
//…
intlistsize;
//……
}SqList；
SqListLa,Lb,Lc;
StatusInitList_Sq（SqList&
L）
{//构造空线性表L
L.elem=（ElemType*）malloc（LIST_INIT_SIZE
*sizeof（ElemType））
if（L.elem==0）exit（OVERFLOW）;
L.length=0;
//初始化表长为0，“空”表
L.listsize=LIST_INIT_SIZE;
//初始化存储容量
return（OK）;
}//InitList_Sq
voidListDelete（SqList&
L,inti,ElemType&
e）
{//在顺序表L中删除第ｉ个元素，用ｅ返回其值．
//i的合法值是[1，ListLength（L）]
if（i<
1||i>
L.length）returnERROR;
//删除位置不合理
ElemType*p=&
L.elem[i-1],*q=L.elem+L.length-1;
e=*p;
while（p<
q）{*p=*（p+1）;
++p;
}//删除位置后元素左移
--L.length;
returnOk;
}//ListDelete_Sq
StatusListInsert_Sq（SqList&
L,inti,ElemTypee）
{//在顺序表L的第i个位置前插入元素e,i的合法值为1..L.length+1
L.length+1）returnERROR;
//插入不合法
if（L.length>
=L.listsize）
{//表满，增加存储容量
ElemType*newbase=（ElemType*）realloc
（L.elem,（L.listsize+LISTINCREMENT）*sizeof（ElemType））
if（!
newbase）exit（OVERFLOW）;
L.elem=newbase;
L.listsize+=LISTINCREMENT;
}
ElemType*q=&
L.elem[i-1],*p=&
L.elem[L.length-1];
while（p>
=q）
{*（p+1）=*p;
--p;
}//插入位置后的元素右移
*q=e;
++L.length;
returnOK;
}//ListInsert_S
线性表相关程序：
typedefstructLNode{
ElemTypedata;
//数据域
structLNode*next;
//指针域
}LNode,*LinkList;
//默认带头结点,需说明
LNodenode1;
LinkListLa；
StatusGetElem_L（LinkListL,inti,ElemType&
{//L为带头结点的单链表的头指针。
第i个元素存在时,其值赋给e并返回OK,否则返回ERROR
LNode*p=L->
next;
//p指向”第1个”结点，
intj=1;
//j为指向结点的位序
while（p&
&
j<
i）
{//顺序查找，只要p不空且未到第i结点就前进
p=p->
++j;
}
if（!
p）returnERROR;
//第i个元素不存在
e=p->
data;
//取第i个元素
returnOK；
StatusListInsert_L（LinkList&
L,inti,ElemTypee）
{//向链表L中第i个位置插入e
LNode*p=L;
intj=0;
/*p始终指向第j个结点*/
while（p&
i-1）{p=p->
++j;
}//寻找第i-1个结点
p）returnERROR;
LNode*temp;
temp=（LNode*）Malloc（sizeof（LNode））;
temp）exit（OVERFLOW）;
temp->
data=e;
temp->
next=p->
p->
next=temp;
return（OK）;
}//ListInsert_L
StatusListDelete_L（LinkList&
L,inti,ElemType&
{
LNode*p=L,*q;
}//寻找第i-1个结点，j最终为i-1,除非到表尾p空
p||!
p->
next）
returnERROR;
//第i个或更前结点不存在
q=p->
e=q->
p->
next=q->
free（q）;
return（OK）;
}//ListDelete_L
StatusCreateList_L（LinkList&
L,intn）
{//逆位序输入n个元素的值，建立带头结点的单链表L。
LNode*p;
L=（LinkList）malloc（sizeof（LNode））;
L->
next=NULL;
for（inti=1;
i<
=n;
++i）
p=（LNode*）malloc（sizeof（LNode））;
//LNode*等同LinkList
scanf（“…”,&
data）;
next=L->
next=p;
//插入到表头
}//CreateList_L
相关两表的归并
voidMergeList_Sq（SqListLa,SqListLb,Sqlist&
Lc）
{//归并非降顺序表La与Lb构成非降顺序表Lc
Lc.listsize=Lc.length=La.length+Lb.length;
Lc.elem=（ElemType*）
malloc（Lc.listsize*sizeof（ElemType））;
If（!
Lc.elem）exit（OVERFLOW）;
//存储分配失败
ElemType*pa=La.elem,*pb=Lb.elem,*pc=Lc.elem;
ElemType*pa_last=La.elem+La.listsize-1;
ElemType*pb_last=Lb.elem+La.listsize-1;
while（pa<
=pa_last&
pb<
=pb_last）
{//归并
if（*pa<
=*pb）*pc++=*pa++;
else*pc++=*pb++;
pa_last）*pc++=*pa++;
//插入La剩余段
while（pb<
pb_last）*pc++=*pb++;
//插入Lb剩余段
}//MergeList_Sq
StatusListMerge_SortedL
（SortedSqListLa,SortedSqListLb,SortedSqList&
{//将两个有序顺序表La与Lb归并为有序顺序表Lc
intla_len=ListLength_Sq（La）;
intlb_len=ListLength_Sq（Lb）;
inti=1,j=1,k=1;
ElemTypea,b;
InitList_Sq（Lc）;
while（i<
=la_len&
=lb_len）
{//归并
GetElem_Sq（La,i,a）;
GetElem_Sq（Lb,j,b）;
if（a<
b）{ListInsert_Sq（Lc,k++,a）;
++i;
else{ListInsert_Sq（Lc,k++,b）;
}
while（i<
=la_len）//插入La的剩余元素
{GetElem_Sq（La,i++,a）;
ListInsert_Sq（Lc,k++,a）;
while（j<
=lb_len）//插入Lb的剩余元素
{GetElem_Sq（Lb,j++,b）;
ListInsert_Sq（Lc,k++,b）;
returnOK;
}//复杂度O（ListLength（La）+ListLength（Lb）,因只在表尾插入）
3.注意链表中next指针的应用，如插入，删除等操作各个元素的链接。
4.顺序表的就地逆置思路：
分别设两个指针p与q指向第一个和最后一个元素，当p<
q时{*p与*q互换，之后++p,--q}。
单链表的就地逆置思路：
令指针p指向首元结点,头结点断开,{将p所指结点插入到表头后,p后移,直至p为空}
StatusListInverse_Sq（SqList&
{//顺序表就地逆置
ElemType*p,*q;
ElemTypee;
p=L.elem;
q=L.elem+L.length-1;
q）
temp=*p;
*p=*q;
*q=temp;
--q;
StatusListInverse_L（LinkList&
//思路:
令指针p指向首元结点,头结点断开,{将p所指结点插入到表头后,p后移,至p空}
LNode*p,*q;
p=L->
L->
while（p!
=NULL）
q=p->
//令q指向p的后继结点，以便以后p后移接下来两句将p所指向节点插入到头结点后
p=q;
//q后移
有序顺序表插入
StatusListInsert_SortedSq（SqList&
L,ElemTypee）
{//在非降顺序表L中插入元素e,使得L中各元素仍然非降。
注意插入位置据e求得
//思路：
从最后一个元素开始，只要它比待插入元素大就后移。
条件不成立时退出循环，将e插入当前位置后即可。
顺序表插入操作莫忘表满的处理。
只要是顺序表的插入操作就需要判断是否表满，对于链表则无此要求
if（L.length>
{//表满，增加存储容量
ElemType*newbase=（ElemType*）
realloc（L.elem,（L.listsize+LISTINCREMENT）
*sizeof（ElemType））;
if（!
L.listsize+=LISTINCREMENT;
//下面从最后一个元素开始，只要大于e就后移，最后插入当前位置后
p=L.elem+L.length-1;
while（p>
=L.elem&
*p>
e）{*（p+1）=*p;
--p;
*（p+1）=e;
++L.length;
//表长加1
5.循环链表、双向链表、双向循环链表的特点和基本操作。
主要是插入删除的相关指针操作。
//---线性表的双向（循环）链表存储结构---
typedefstructDuLNode
ElemTypedata;
structDuLNode*prior;
structDuLNode*next;
}DuLNode,*DuLinkList;
StatusListInsert_DuL（DuLinkList&
{//在带头结点的双向链表L的第i个位置插入e,1≤i≤表长+1
DuLNode*p=L;
while（j<
i-1&
p）{p=p->
s=（DuLNode*）malloc（sizeof（DuLNode））;
s）exit（OVERFLOW）;
s->
prior=p;
s->
//记:
注意分析指针改变
next->
prior=s;
next=s;
//次序对结果的影响
另外看下多项式的相关课件，老师复习提纲上有写这方面的代码。
第三章栈和队列
1.栈（Stack）是定义在线性结构上的抽象数据类型，其操作类似线性表操作，但元素的插入、删除和访问都必须在表的一端进行，为形象起见，称允许操作端为栈顶（Top），另一端为栈底（base），注意Top指向待插入位置。
特性:
LastInFirstOut后进先出//总是访问最近插入的一个//按插入顺序倒着访问。
#defineSTACK_INIT_SIZE100
#defineSTACKINCREMENT10
typedef?
?
SElemType;
//栈元素类型
SElemType*base;
//栈底指针
SElemType*top;
//栈顶指针
intstacksize;
//栈容量
}SqStack
StatusInitStack（SqStack&
S）
{//构造空栈S
S.base=（SElemType*）
malloc（STACK_INIT_SIZE*sizeof（SElemType））;
S.base）exit（OVERFLOW）;
S.top=S.base;
//空栈
S.stacksize=STACK_INIT_SIZE;
}//InitStack复杂度”O
（1）”
StatusDestroyStack（SqStack&
{//销毁栈S
free（S.base）;
S.base=NULL;
S.top=NULL;
S.stacksize=0;
}//复杂度O
（1）
StatusClearStack（SqStack&
{//置S为空栈
S.top=S.base;
StatusPush（SqStack&
S,SElemTypee）
{//插入e为栈顶元素
if（S.top-S.base==S.stacksize）//判断栈满
{//栈满则应重新分配空间
S.base=（SElemType*）realloc（S.base,
（S.stacksize+STACKINCREMENT）*sizeof（SElemType））;
S.base）exit（OVERFLOW）;
S.top=（S.base+S.stacksize）;
//使得S.top重新指向栈顶,因realloc
S.stacksize+=STACKINCREMENT;
*S.top++=e;
//top指向待插入位置
}//Push,复杂度O
（1）
StatusPop（SqStack&
S,SElemType&
{//若栈不空则栈顶元素出栈并用e带回其值
if（S.top==S.base）returnERROR;
//判断栈空
e=*（--S.top）;
//栈顶元素为*（S.top-1）
StatusStackEmpty（SqStackS）
if（S.top==S.base）returnTRUE;
elsereturnFALSE;
intStackLength（SqStackS）{return（S.top-S.base）;
StatusGetTop（SqStackS,SElemType&
e=*（S.top-1）;
//注意top指向待插入位置
栈的遍历一直没用到，可以自己找找课件看。
2.队列类似线性表和栈,也是定义在线性结构上的ADT,与线性表和栈的区别在于，元素的插入和删除分别在表的两端进行。
类似日常生活中排队,允许插入的一端为队尾（rear）,允许删除端称队头（front）。
FirstInFirstOut先进先出，如操作系统中的作业队列和打印任务队列、日常生活中各类排队业务等均可用队列模拟。
#define***QElemType
typedefstructQNode{
QElemTypedata;
structQNode*next;
}QNode,*QueuePtr;
typedefstruct{
QueuePtrfront;
//队头指针
QueuePtrrear;
//队尾指针
}LinkQueue;
//链队列
StatusInitQueue（LinkQueue&
Q）
{//构造一个空队列Q
Q.front=Q.rear=（QueuePtr）malloc（sizeof（QNode））;
if（!
Q.front）exit（OVERFLOW）;
Q.front->
next=NULL;
//莫忘！
！
}//时间复杂度O
（1）
StatusDestroyQueue（LinkQueue&
Q）
{//销毁队列Q，此处不同于教材,先清空元素结点，后释放头结点
QueuePtrp=Q.front->
while（p）
{//依次释放首元素至最后一个元素
Q.front->
free（p）;
p=Q.front->
free（Q.front）;
Q.front=NULL;
Q.rear=NULL;
}//去掉下划线部分为置空操作,复杂度O（n）
StatusEnQueue（LinkQueue&
Q,QElemTypee）
{//插入元素e为Q的新的队尾元素
QueuePtrp;
p=（QueuePtr）malloc（sizeof（QNode））;
p）exit（OVERFLOW）;
//存储分配失败
data=e;
//莫忘！
Q.rear->
next=p;
Q.rear=p;
}//复杂度O
（1）
StatusDeQueue（LinkQueue&
Q,QElemType&
e）
{//若队列不空，则删除Q的队头元素，用e返回其“值”
if（Q.front==Q.rear）returnERROR;
//空队列
QueuePtrp=Q.front->
e=p->
next=p->
if（Q.rear==p）Q.rear=Q.front;
//只1个结点时改尾指针
free（p）;
}//复杂度O
（1）
3.循环队列
#defineMAXQSIZE100//最大队列长度
QElemType*base;
//动态分配存储空间
intfront;
//头指针,队列不空则指向队列头元素
intrear;
//尾指针,指向待插入元素位置
}SqQueue;
StatusInitQueue（SqQueue
升级会员 