线性结构的特点:
(1)存在唯一的一个被称做“第一个”的数据元素;
(2)存在唯一的一个被叫做“最后一个”的数据元素;
(3)除第一个之外,集合中的每个数据元素均只有一个前驱;
(4)除最后一个之外,集合中每个数据元素均只有一个后驱;
2.1线性表的类型定义
ADT List{
数据对象:
数据关系:
基本操作:
InitLisst(&L);
DestroyList(&L);
ClearList(&L);
ListEmpty(L);
ListLength(L);
GetElem(L,i,&e);
LocateElem(L,e,compare());
PriorElem(L,cur_e,&pre_e);
NextElem(L,cur_e,&next_e);
ListInsert(&L,i,e);
ListDelet(&L,i,e);
ListTraverse(L,visit());
}ADT List
/*算法2.1两个线性表的合并*/
void union(List &La,List Lb)
{
la_len=ListLength(La);
lb_len=ListLength(Lb);
for(i=1;i<lb_len;i++)
{
GetElem(Lb,i,e);
if(!LocateElem(La,e,equal))
ListInsert(La,++La_len,e);
}
}
/*算法2.2将两个非递减序列线性链表合并成非递减线性链表*/
void MergeList(List La,List Lb,List &Lc)
{
InitList(Lc);
i=j=1;k=0;
La_len=ListLength(La);
Lb_len=ListLength(Lb);
while((i<=La.len)&&(j<=Lb_len))
{
GetElem(La,i,ai);
GetElem(Lb,j,bj);
if(ai<=bj)
{
ListInsert(Lc,++k,ai);
++i;
}else
{
ListInsert(Lc,++k,bj);
++j;
}
}
while(i<=La_len)
{
GetElem(La,i++,ai);
ListInert(Lc,++k,ai);
}
while(j<=Lb_len)
{
GetElem(Lb,j++,bi);
ListInsert(Lc,++k,bj);
}
}
2.3线性表的顺序表示和实现
/*线性表的动态分配顺序存储结构*/
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef struct
{
ElemType *elem;//存储空间基址
int length;
int listsize;//当前分配存储容量
}SqList;
/*算法2.3顺序表的初始化*/
Status InitList_Sq(SqList &L)
{
L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem)
eixt(OVERFLOW);
L.length=0;
L.listsize=LIST_INIT_SIZE;
return OK;
}
//算法2.4线性表的插入操作
Status ListInsert_Sq(SqList &L,int i,ElemType)
{
if(i<1||i>L.length+1)
return ERROR;
if(L.length>=L.listsize)
{
newbase=(ElemType *)realloc(L.elem,L.(listsize+LISTINREMENT)*sizeof(ElemType));
if(!newbase)exit(OVERFLOW);
L.elem=newbase;
L.listsize+=LISTINCREMENT;
}
q=&(L.elem[i-1]);
for(p=&(L.elem[L.length-1]);p>=q;--p)
*(p+1)=*p;
*q=e;
++L.length;
return OK;
}
//算法2.5线性表的第i个元素删除操作
Status ListDelete_Sq(SqList &L,int i,ElemType &e)
{
if((i<1||(i>L.length))
return ERROR;
p=&(L.elem[i-1]);
e=*p;
q=L.elem+L.length-1;
for(++p;p<=q;++p)
*(p-1)=*p;
--L.Length;
return OK;
}
int LocateElem_Sq(SqList L,ElemType e,Status(*compare)(ElemType,ElemType))
{
//在顺序表L中查找第1个值与e满足compare()元素的位序
//若找到,则返回其在L中的位序,否则返回0
i=1; //i的初始值为第一个元素的位序
p=L.elem; //p的初值为第1个元素的为序
while(i<=L.length&&!(*compare)(*p++,e)) ++1;
if(i<=L.length) return i;
else return 0;
}//LocateElem_Sq
void MergeList_Sq(SqList La,SqList Lb,SqList &Lc)
{
//已知顺序线性表La和Lb的元素按非递减排序
//归并La和Lb得到新的顺序线性表Lc,Lc的元素也按值非递减排列
pa=La.elem;pb=Lb.elem;
Lc.listsize=Lc.length=La.length+Lb.length;
pc=Lc.elem=(ElemType*)malloc(Lc.listsize*sizeof(ElemType));
if(!Lc.elem)exit(OVERFLOW);
pa_last=La.elem+La.length-1;
pb_last=Lb.elem+Lb.length-1;
while(pa<=pa_last&&pb<=pb_last)
{
if(*pa<=*pb) *pc++=*pa++;
else *pc++=*pb++;
}
while(pa<=pa_last) *pc++=*pa++; //插入La的剩余元素
while(pb<=pb_last) *pc++=*pb++; //插入Lb的剩余元素
}
2.3线性链表的表示和实现
//线性链表的单链表存储结构
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//单链表是非随机存储的数据结构
//算法2.8
Status GetElem_L(LinkList L,int i,ElemType &e)
{
//L为带头结点的单链表的头指针
//当第i个元素存在时,其值赋给e并返回OK,否则返回false
p=L->next; j=1;//初始化,p指向第一个节点,j为计数器
while(p&&j<i)
{
p=p->next; ++j;
}
if(!p||j>j) return EROOR;//第i个元素不存在
e=p->data;
return OK;
}
/*除了函数的参数需要说明类型外,算法中使用的辅助变量可以不作变量说明
,必要时对其作用给予注释。一般而言,a,b,c,d,e等用作数据元素名,i,j,k,l,m,n
等用作整型变量名,p,q,r等用作指针变量名。当函数返回值为函数结果状态代码时,
函数定义为Status类型。为了便于描述,除了值调用方式外,增添了C++语言引用调用
的参数传递方式。在形参表中,以&打头的参数即为引用参数*/
//算法2.9
Status ListInsert_L(LinkList &L,int i,ElemType e)
{
//在带头结点的单线性链表中第i个位置之前插入元素e
p=L; j=0;
while(p&&j<=i-1)
{
p=p->next; ++j;//寻找第i-1个节点
}
if(!p||j>i-1)return ERROR;//i小于或者大于表长+1
s=(LinkList)malloc(sizeof(LNode));
s->data=e;s->next=p->next;
p->next=s;
return OK:
}
//算法2.10
Status ListDelete_L(LinkList &L,int i,ElemType &e)
{
//在带头结点的但线性表L,中删除第i个元素,并由e返回其值
p=L; j=0;
while(p->next&&j<i-1){//寻找第i个结点,并令p指向其前驱
p=p->next; ++j;
}
if(!(p->next)||j>i-1)return ERROR;//删除位置不合理
q=p->next; p->next=q->next; //删除并释放结点
e=q->data; free(q);
}
//算法2.11
void CreateList_L(LinkList &L,int n)
{
//逆位序输入n个元素的值,建立带表头结点的单线性链表L
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL; //先建立一个带头结点的单链表
for(i=n;i>0;--i)
{
p=(LinkList)malloc(sizeof(LNode));//生成新结点
scanf(&p->data); //输入元素值
p->next=L->next; L->next=p; //插入到表头
}
}
//算法2.12
void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc)
{
//已知单链表La和Lb的元素按非递减排序
//归并La和Lb得到新的单链表表Lc,Lc的元素也按值非递减排列
pa=La->next; pb=Lb->next;
Lc=pc=La;
while(pa&&pb)
{
if(pa->data<=pb->data)
{
pc->next=pa;
pc=pa;
pa=pa->next;
}
else{pc->next=pb;pc=pb;pb=pb->next;}
}
pc->next=pa?pa:pb; //插入剩余段
free(Lb); //释放Lb的头结点
}
静态链表
//线性表的静态单链表存储结构
#define MAXSIZE 1000//链表的最大长度
typedef struct
{
ElemType data;
int cur;
}component,SLinkList[MAXSIZE];
//算法2.13
int LocateElem_SL(SLinkList S,ElemTpye e)
{
//在静态单线性表L中查找第1个值为e的元素
//若找到,则返回它在L中的位序,否则返回0
i=S[0].cur;
//i指示表中的第一个结点
while(i&&S[i].data!e) i=S[i].cur; //在表中顺序查找
return i;
}
/*【例2-3】运算(A-B)U(B-A)*/
//假设由终端输入集合元素,先建立表示集合A的静态链表S
//而后在输入集合B的元素的同时查找S表,若存在和B相同的元素
//则从S表中删除之,否则将此元素插入S表
//算法2.14 静态单链表的初始化
void InitSpace_SL(SLinkList &space)
{
//将一位数组space中各个分量链成一个备用链表,space[0].cur为头
指针
//"0"表示空指针
for(i=0;i<MAXSIZE-1;i++) space[i].cur=i+1;
space[MAXSIZE-1].cur=0;
}
//算法2.15 从备用链表中申请一个结点空间
int Malloc_SL(SLinkList &space)
{
//若备用链表非空,则返回分配的结点的下标,否则返回0
i=space[0].cur;
if(space[0].cur) space[0].cur=space[i].cur;
return i;
}
//算法2.16 将下标为k的空闲空间回收到备用链表
void Free_SL(SLinkList &space,int k)
{
space[k].cur=space[0].cur;
space[0].cur=k;
}
//算法2.17
void differnce(SLinkList &space,int k)
{
//依次输入集合A和B的元素,在一维数组space中建立表示集合(A-B)U(B-A)
//的静态链表,S为其头指针。假设备用空间足够大,space[0].cur为其头指针
InitSpace_SL(space); //初始化备用空间
S=Malloc_SL(space); //生成S的头结点
r=S; //r指向S的当前最后结点
scanf(m,n); //输入集合A和集合B的元素个数
for(j=1;j<=m;++j)
{
i=Malloc_SL(space);//分配结点
scanf(space[i].data);//输入A的元素值
space[r].cur=i;r=1; //插入到表尾
}
space[r].cur=0; //尾点指针为空
for(j=1;j<=n;j++)
{
//依次输入B的元素值,若不在当前表中,则插入,否则删除
scanf(b);p=S;k=space[S].cur;//k指向集合中第一个节点
while(k!=space[k].cur&&space[k].data!b)//在当前表中查找
{
p=k;
k=space[k].cur;
}//while
if(k==space[r].cur)//当前表中不存在该元素,插入在r所在结点之后,且r的位置不变
{
i=Malloc_SL(space);
space[i].data=b;
space[i].cur=space[r].cur;
space[r].cur=i;
}//if
else{ //该元素已在表中,删除它
space[p].cur=space[k].cur;
Free_SL(space,k);
if(r==k) r=p;
}//else
}//for
}//difference
循环链表
双向链表
//线性表的双向链表存储结构
typedef struct DuLNode
{
ElemType data;
struct DuLNode *prior;
struct DuLNode *next;
}DuLNode,*DuLinkList;
Status ListDelete_DuL(DuLinkList &L,int i,ElemType &e)
{
//删除带头结点的双链循环线性表L中第i个元素,i的合法值为1<=i<=表长
if(!(p=GetElemP_DuL(L,i)))
return ERROR;
e=p->data;
p->prior->next=p->next;
p->next->prior=p->prior;
free(p);
return OK;
}//ListDelete_DuL
Status ListInsert_DuL(DuLinkList &L,int i,ElemType e)
{
//在带头结点的双链循环线性表L中第i个位置之前插入元素e
//i的合法值为1<<i<<表长+1
if(!(p=GetElemP_DuL(L,i)))//在L中确定插入位置指针p
return ERROR;
if(!(s=(DuLinkList)malloc(sizeof(DuLNode))))
return ERROR;
s->data=e;
s->prior=p->prior; p->prior->next=s;
s->next=p; p->prior=s;
return OK;
}//ListInsert_DuL
由于链表在空间的合理利用上和插入、删除时不需移动等优点,
在很多场合下,它是线性表的首选存储结构。然而,它也存在着实现
某些基本操作,如求线性表的长度时不如顺序存储结构的缺点;
另一方面,由于在链表中,结点之间的关系用指针来表示,则数据元素在线性表中的“位序”概念已弱化,而被数据元素在线性表中的“位置”所代替。
为此,从实际应用出发角度重新定义线性表及其基本操作
带头结点的线性链表
//一个带头结点的线性链表类型定义如下
typedef struct LNode
{
ElemType data;
struct LNode *next;
}*Link,*Position;
typedef struct //链表类型
{
Link head,tail; //分别指向线性链表中的头结点和最后一个结点
int len; //指示线性表中数据元素的个数
}LinkList;
//算法2.21
Status ListInsert_L(LinkList &L,int i,ElemType e)
{
//在带头结点的单链线性表L的第i个元素之前插入元素
if(!LocatePos(L,i-1,h)) return ERROR; //插入位置不合理
if(!MakeNode(s,e)) return ERROR; //结点存储分配失败
InsFirst(h,s);//对于从第i个结点开始的链表,第i-1个结点是它的头结点
return OK;
}//ListInsert_L
//算法2.21
Status MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc),int (*compare)(ElemType,ElemType))
{
//已知单链线性表La和Lb的元素按非递减排列
//归并La和Lb得到的新单链表Lc,Lc的元素值非递减排列
if(!InitList(Lc)) return ERROR; //存储空间分配失败
ha=GetHead(La); hb=GetHead(Lb); //ha,hb分别指向La和Lb的头结点
pa=NextPos(La,ha); pb=NextPos(Lb,hb);//pa和pb分别指向La和Lb中当前结点
while(pa&&pb) //La和Lb均非空
{
a=GetcurElem(pa); b=GetCurElem(pb);//a和b为两表中当前比较元素
if((*compare)(a,b)<=0)
{
DeFirst(hb,q);
Append(Lc,q);
pa=Nextpos(La,ha);
}else{
DeFirst(hb,q);
Append(Lc,q);
pb=NextPos(Lb,hb);
}
}//while
if(pa) Append(Lc,pa); //链接La中剩余结点
else Append(Lc,pb); //链接Lb中剩余结点
FreeNode(ha); FreeNode(hb);//释放La和Lb的头结点
return OK;
}//MergeList_L