一.线性表的基本概念
1.定义:具有相同特性的数据元素的有限序列。
2.逻辑特征:起始元素没有前驱元素,其他元素有且仅有一个前驱元素;终端元素没有后继元素,其他元素有且仅有一个后继元素。
3.存储结构:顺序储存,链式储存两种。
3.1顺序表:把元素按照逻辑顺序依次储存到连续的存储空间。即逻辑顺序与物理顺序一致。
这样线性表第一个元素的储存位置就是指导储存空间的起始位置,第i+1个元素储存位置紧邻第i个元素的储存位置。
顺序表无需为元素的逻辑关系增加额外的存储空间,可以随机存取任一元素。
但是占用了整片连续的存储空间,插入和删除需要移动大量的元素,十分不便。
3.1.1顺序表的算法:借助数组实现,可以是静态分配或者动态分配。
静态分配时数组大小和空间固定,一旦占满,再加入新的数据就会溢出。
#define MaxSize 50
typedef struct
{
ElemType data[MaxSize];//存放顺序表的元素
int length; //存放顺序表的长度
}SqList; //声明顺序表的类型
动态分配时数组大小和空间在程序执行过程中通过动态储存分配语句分配,一旦占满,就开辟更大的代替。
#define InitSize 100
typedef struct
{
ElemType *data;//存放顺序表的元素
int length,MaxSize; //存放顺序表的长度和最大容量
}SqList; //动态分配顺序表的类型定义
初始化:时间复杂度O(1)
void InitList(SqList &L)
{
L.length=0;
}
求指定位置元素值:时间复杂度O(1)
void GetElem(SqList L,int i,ElemType &e)
{
if(i<1||i>L.length)
return 0;
e=L.data[i-1];
return 1;
}
求指定元素值:时间复杂度O(n)
int LocateElem(SqList L,ElemType e)
{
int i;
for(i=0;i<L.length;i++)
if(L.data[i]==e)
return i+1;
return 0;
}
插入元素:时间复杂度O(n)
int ListInsert(SqList &L,ElemType e,int i)
{
int j;
if(i<1||i>L.length+1)
return 0;
for(j=L.length;j>i;j--)
L.data[j]=L.data[j-1];
L.data[i-1]=e;
L.length++;
return 1;
}
删除元素:时间复杂度O(n)
int ListDelete(SqList &L,int i,ElemType &e)
{
int j;
if(i<1||i>L.length)
return 0;
e=L.data[i-1];
for(j=i;j<L.length;j++)
L.data[j-1]=L.data[j];
L.length--;
return 1;
}
有序顺序表的归并:时间复杂度O(n+m)
void Merge(SqList L1,SqList L2,SqList &L3)
{
int i=0,j=0,k=0;
while(i<L1.length && j<L2.length)
{
if(L1.data[i]<L2.data[j])
{
L3.data[k]=L1.data[i];
i++;k++;
}
else
{
L3.data[k]=L2.data[j];
j++;k++;
}
}
while(i<L1.length)
{
L3.data[k]=L1.data[i];
i++;k++;
}
while(j<L2.length)
{
L3.data[k]=L2.data[j];
j++;k++;
}
L3.length=k;
}
3.2链表:每个节点储存一个元素(数据域)以及元素的关系,即前驱节点包含后继节点的位置信息(指针域)。
如果某个节点的指针域不指向如何其他节点,那么值置空(NULL)。
因为带有指针域,所以使用了更多地存储空间,也无法随机存储,但是进行删除和插入操作时只需要修改相关节点的指针域,不需要移动节点。
3.2.1单链表:除数据域外,只设置一个指针域,指向后继节点。解决了需要连续存储单元的缺点,但是浪费存储空间。是非随机存取结构。通常使用头指针标识单链表,设置头节点。使用头结点可以存放第一个数据元素的位置,所以第一个数据元素与其他位置的操作一致,空表与非空表的处理也一致。
节点类型使用LinkList表示,声明如下:
typedef struct LNode
{
ElemType data; //数据域
struct LNode *next;//指向后继节点的指针
}LinkList; //声明单链表节点类型
头插法建立单链表(倒序):时间复杂度O(n)
void CreateListF(LinkList &L)
{
LinkList *s;int i;
L=(LinkList *)malloc(sizeof(LinkList)); //创建头节点
L->next=NULL; //头节点next域置NULL
for(i=0;i<n;i++)
{
s=(LinkList *)malloc(sizeof(LinkList)); //创建新节点
s->data=i;
s->next=L->next; //*s插入头节点之后
L->next=s;
}
}
尾插法建立单链表(正序):时间复杂度O(n)
void CreateListR(LinkList &L)
{
LinkList *s,*r;int i;
L=(LinkList *)malloc(sizeof(LinkList)); //创建头节点
r=L; //r始终指向尾节点,开始时指向头节点
for(i=0;i<n;i++)
{
s=(LinkList *)malloc(sizeof(LinkList)); //创建新节点
s->data=i;
r->next=s; //*s插入*r之后
r=s;
}
r->next=NULL;
}
按元素值查找: 时间复杂度O(n)
void LocateElem(LinkList *L,ElemType e)
{
LinkList *p=L->next; //p指向第一个节点
int n=1;
while(p!=NULL && p->data!=e)
{
p=p->next;
n++;
}
if(p==NULL) return 0;
else return n;
}
按序号值查找: 时间复杂度O(n)
void GetElem(LinkList *L,ElemType e)
{
int j=1;
LinkList *p=L->next; //p指向第一个节点
if(e==0) return L;
if(e<0) return NULL;
while(p && j<e)
{
p=p->next;
j++;
}
return p;
}
插入节点:即先查找插入节点的前一个节点位置,然后插入
p=GetElem(L,e-1);
s->next=p->next;
p->next=s;
删除节点:即先查找插入节点的前一个节点位置,然后删除
p=GetElem(L,e-1);
p->next=p->next->next;
有序单链表的归并
1.尾插法建立L3,时间复杂度O(n+m),空间复杂度O(n+m)
void Merge(LinkList *L1,LinkList *L2,LinkList &*L3)
{
LinkList *p=L1->next,*q=L2->next,*r,*s; //pq分别遍历L1L2
L3=(LinkList *)malloc(sizeof(LinkList));//创建L3的头节点
r=L3; //r指向L3的尾节点
while(p!=NULL && q!=NULL)
{
if(p->data[]<q->data[])
{
s=(LinkList *)malloc(sizeof(LinkList));//复制*p得到*s
s->data[]=p->data[];
p=p->next;
r->next=s; //*s连接到L3末尾
r=s;
}
else
{
s=(LinkList *)malloc(sizeof(LinkList));//复制*q得到*s
s->data[]=q->data[];
q=q->next;
r->next=s; //*s连接到L3末尾
r=s;
}
}
if(q!=NULL) p=q;
while(p!=NULL)
{
s=(LinkList *)malloc(sizeof(LinkList));//复制*p得到*s
s->data[]=p->data[];
p=p->next;
r->next=s; //*s连接到L3末尾
r=s;
}
r->next=NULL;
}
2.破坏L1L2重组L3,时间复杂度O(n+m),空间复杂度O(1)
void Merge(LinkList *L1,LinkList *L2,LinkList &*L3)
{
LinkList *p=L1->next,*q=L2->next,*r,; //pq分别遍历L1L2
L3=L1;//L1的头节点做L3的头节点
free(L2); //释放L2的头节点
r=L3;
while(p!=NULL && q!=NULL)
{
if(p->data[]<q->data[])
{
r->next=p; //*p连接到L3末尾
r=s;
p=p->next;
}
else
{
r->next=p; //*q连接到L3末尾
r=s;
q=q->next;
}
}
if(q!=NULL) p=q;
r->next=p; //未遍历的表的其余节点连接到L3末尾
}
3.2.2双链表:设置两个指针域,分别指向前驱和后继节点。
节点类型描述:
typedef struct DNode{
ElemType data; //数据域
struct DNode *prior,*next;//前驱,后继指针
}DNode,*DLinklist;
插入
//头插法
void CreateDListF(DLinkList *&L,ElemType a[],int n)
{
DLinkList *s;
int i;
L=(DLinkList *)malloc(sizeof(DLinkList));//创建头节点
L->next=L->prior=NULL;//创建空双链表
for(i=0;i<n;i++)
{
s=(DLinkList *)malloc(sizeof(DLinkList));//创建新的节点
s->data=a[i];
s->next=L->next;//将*s插在首节点前,头节点后
if(L->next!=NULL)
L->next->prior=s;
L->next=s;
s->prior=L;
}
}
//尾插法
void CreateDListR(DLinkList *&L,ElemType a[],int n)
{
DLinkList *s,*r;
int i;
L=(DLinkList *)malloc(sizeof(DLinkList));//创建头节点
r=L;//r始终指向终端节点,开始时指向头结点
for(i=0;i<n;i++)
{
s=(DLinkList *)malloc(sizeof(DLinkList));//创建新的节点
s->data=a[i];
r->next=s;//将*S插入*r后
s->prior=r;
r=s;
}
r->next=NULL;
}
查找指定值的节点
//尾插法
int Finfnode(DLinkList *L,ElemType x)
{
LinkList *p=L->next;
int i=1;
while(p!=NULL&&p->data!=x)
{
i++;
p->next;
}
if(p==NULL) return 0;
else return i;
}
插入
int ListInsert(DLinkList *&L,ElemType e,int i)
{
int j=0;
DLinkList *p=L,*s;
while(j<i-1&&p!=NULL)
{
j++;
p=p->next;
}
if(p==NULL)
return 0;
else
{
s=(DLinkList *)malloc(sizeof(DLinkList));
d->data=e;
s->next=p->next;
if(p->next!=NULL)
p->next->prior=s;
s->prior=p;
p->next=s;
return 1;
}
}
删除
int ListDelete(DLinkList *&L,ElemType &e,int i)
{
int j=0;
DLinkList *p=L,*q;
while(j<i-1&&p!=NULL)
{
j++;
p=p->next;
}
if(p==NULL)
return 0;
else
{
q=p->next;
if(p==NULL) return 0;
p->next=q->next;
if(p->next!=NULL)
q->next->prior=p;
free(q);
return 1;
}
}
3.2.3循环链表:表中尾节点的指针域不是空,而是指向表头节点,整个链表形成环。
对于循环单链表判空条件不是头节点的指针是否为空,而是是否等于头指针。
//头插法
void CreatCListF(LinlList *&L,ElemType a[],int n)
{
LinkList *s;int i;
L=(LinkList *)malloc(sizeof(LinkList));
L->next=L;//设置为空
for(i=0;i<n:i++)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=a[i];
s->next=L->next;
L->next=s;
}
}
//尾插法
void CreatCListR(LinlList *&L,ElemType a[],int n)
{
LinkList *r,*s;int i;
L=(LinkList *)malloc(sizeof(LinkList));
r=L;//尾指针指向终端节点
for(i=0;i<n:i++)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=a[i];
r->next=s;
r=s;
}
r->next=L;
}
//查找值
int FinDList(LinlList *L,ElemType x)
{
LinkList *p=L->next;
int n=1;
while(p!=L&&p->data!=x)
{
p=p->next;
n++;
}
if(p==L) return 0;
else return n;
}
//插入
q->next=p->next;
p->next=q;
//删除
p->next=p->next->next;
对于循环双链表判空条件是头结点的prior和next等于L。
//头插法
void CreatCDListF(LinlList *&L,ElemType a[],int n)
{
DLinkList *s;int i;
L=(DLinkList *)malloc(sizeof(DLinkList));
L->next=L->prior=L;//设置为空
for(i=0;i<n:i++)
{
s=(DLinkList *)malloc(sizeof(DLinkList));
s->data=a[i];
s->next=L->next;
if(L->next!=NULL)
L->next->prior=s
L->next=s;
s->prior=L;
}
}
//尾插法
void CreatCDListR(LinlList *&L,ElemType a[],int n)
{
LinkList *r,*s;int i;
L=(DLinkList *)malloc(sizeof(DLinkList));
r=L;//尾指针指向终端节点
for(i=0;i<n:i++)
{
s=(DLinkList *)malloc(sizeof(DLinkList));
s->data=a[i];
r->next=s;
s->prior=r;
r=s;
}
r->next=L;
L->prior=r;
}
//查找值
int FinCDList(LinlList *L,ElemType x)
{
DLinkList *p=L->next;
int n=1;
while(p!=L&&p->data!=x)
{
p=p->next;
n++;
}
if(p==L) return 0;
else return n;
}
//插入
q->next=p->next;
p->next->prior=q;
q->prior=p;
p->next=q;
//删除
q=p->next;
p->next=q->next;
q->next->prior=p;
3.2.4静态链表:借用一维数组描述线性链表,数组的分量表示元素,游标代替指针。需要预先分配一块连续的内存空间。以next=1结束。
#define MaxSize 50
typedef struct{
ElemType data;
int next;
}SLinkList[MaxSize];