数据结构-线性表
一、线性表的定义
线性表(List)：零个或多个数据元素的有限序列
二、线性表的抽象数据类型
ADT 线性表 (List) Data Operation lnitList(＊L)；//初始化操作，建立一个空的线性表 ListEmpty(L)；//若线性表为空,返回true，否则返回false ClearList(＊L)；//清空线性表 GetElem(L,i,＊e)；//将线性表L中的第i个位置元素值返回给e LocateElem(L,e)；//在线性表L中查找与e相等的元素，若有，返回元素的序号，否则追回0表示失败 Listlnsert(＊L,i,e)；//在线性表L中的第i个位置插入新元素e ListDelete(＊L,i,＊e)；//删除线性表L中第i个位置元素，并用e返回其值 ListLength(L)；//返回线性表L的元素个数 endADT
三、顺序存储定义
线性表的顺序存储定义：用一段地址连续的存储单元依次存储线性表的数据元素
1、顺序存储方式
线性表的每个数据元素的类型都相同，所以可以使用一维数据来实现顺序存储结构，即把第一个数据元素存放在数组下标为0的位置中，然后接着把线性表相邻的元素存放在数组相邻的位置
1、顺序存储的结构代码 #define MAXSIZE 20 /*存储空间初始化分配量*/ #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int Status typedef int ElemType； typedef Struct { ElemType data[MAXSIZE]; /*数组存储数据元素*/ int length; /*线性表当前长度*/ }SqList； // 描述顺序存储结构的三个属性 // 存储空间的起始位置：数组data，它的位置就是存储空间的位置 // 线性表的最大存储容量：数组长度MAXSIZE // 线性表的当前长度：length
2、顺序存储结构的操作
初始化顺序表
void lnitList(SqList L)
{
if (L == NULL) { return; }
L->length=0;
}
//算法的时间复杂度为O(1)
获取元素
Staus GetElem(SqList L，int i，ElemType *e） { if(L.length==0 || i<1 || i>L.length) return ERROR ; *e=L.data[i-1] ; return OK ; }
//算法的时间复杂度为O(1)
插入操作
// 算法思路：插入位置不合理，抛出异常 // 如果线性表长度大于等于数组长度，则抛出异常或动态增加容量 // 从最后一个元素向前遍历到第i个位置，分别将他们向后移动一个位置 // 将要插入的元素填入i处
// 表长加1 Status Listlnsert(SqList L，int i，ElemType *e） { int k; if (L->length==MAXSIZE)return ERROR;/*线性表已满*/ if (i<1 || i>L->length+1)return ERROR;/*当i不在范围*/ if (1<=L->length)/*当i不在表尾*/ { for (k=L->length-1; k>=i-1; k--) { L->data[K+1]=L->data[k]; } } L->data[i-1]=e;/*插入新元素*/ L->length++;/*表长加一*/ return OK; }
//算法的时间复杂度为O(n)
删除操作
// 算法思路：删除位置不合理，抛出异常 // 取出删除的元素 // 从删除元素位置开始遍历到最后一个元素的位置 // 分别将他们向前移动一个位置 // 表长减一 Status ListDelete(SqList L，int i，ElemType *e） { int k; if (L->length==0)return ERROR;/*线性表为空*/ if (i<1 || i>L->length)return ERROR;/*当i不在范围*/ *e=L->data[i-1]; if (1<L->length)/*当i不在表尾*/ { for (k=i; k<L->length; k++) { L->data[K-1]=L->data[k]; } } L->length--；/*表长减一*/ return OK; }
//算法的时间复杂度为O(n)
线性表的顺序存储结构在存、读数据的时候，不管是哪个位置，时间复杂度都为0(1)；而插入或删除时，时间复杂度都是0（n）
四、线性表的顺序存储结构的优缺点和特点
优点：无须为表示表中元素之间的逻辑关系为增加额外的存储空间
可以快速地存取表中任一位置的元素
缺点：插入和删除操作需要移动大量元素
当线性表长度变化较大时，难以确定空间的容量
造成存储空间的“碎片”
五、线性表的链式存储结构定义
为了表示每个数据元素与它的后继数据元素的逻辑关系，对于数据元素a来说，除了存储其本身的信息之外（数据域），还需要存储一个指示其直接后继的存储位置（指针域）。这两部分信息组成数据元素a的存储映像，称为结点（Node）。
n个结点链成一个链表，即为线性表（a1，a2，a3，...，an）的链式存储结构
1、单链表
在每个结点中除包含有数据域外，只设置一个指针域，用以指向其后继结点
头指针：链表中的第一个结点的存储位置叫做头指针
头结点：在单链表的第一个结点前附设一个结点，叫做头结点
/*线性表的单链表存储结构*/
typedef struct Node { ElemType data; struct Node *next; }Node; typedef struct Node *LinkList;/*定义LinkList*/
1.1单链表的创建
(1)头插法建立单链表
从一个空表开始，读取数组a的元素，生成新结点，将读取的数据放在新结点的数据域中，然后将新结点插入到当前链表的表头，直到结束为止
void CreateListF(LinkList *&L,ElemType a[],int n) { LinkList *s;int i; L=(LinkList*)malloc(sizeof(LinkList));/*创建头结点*/ L->next=NULL; for (i = 0; i < n; i++) { s=(LinkList*)malloc(sizeof(LinkList));/*创建新结点*/ s->data=a[i]; s->next=L->next; L->next=s; } }
(2)尾插法建立单链表
从一个空表开始，读取数组a的元素，生成新结点，将读取的数据放在新结点的数据域中，然后将新结点插入到当前链表的尾结点，但是要增加一个尾结点指针r。使他始终指向当前链表的表尾上，直到结束为止
void CreateListR(LinkList *&L,ElemType a[],int n) { 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=a[i]; r->next=s;/*将*s插入到*r之后*/ r=s; } r->next=NULL;/*尾结点的next域设置为NULL*/ }
1.2单链表的读取
获取第i个数据的算法思路
- 声明一个指针p指向链表第一个结点，初始化j从1开始
- 当j<i时，就遍历链表，让p指针向后移动，不断指向先一个结点，j累加1
- 若到链表末尾p为空，说明第i个结点不存在
- 否则查找成功，返回结点p的数据
Status GetElem(LinkList L,int i,ElemType *e) { int j; LinkList p;/*声明一个指针p*/ p=L->next;/*让p指向链表L的第一个结点*/ j=1; while(p && j<1) { p=p->next; ++j; } if (!p || j>i)return ERROR; *e=p->data;return OK; }
1.3单链表的插入与删除
单链表第i个数据插入结点的算法思路
- 声明一个指针p指向链表的头结点，初始化j从1开始
- 当j<i时，就遍历链表，让p指针向后移动，不断指向先一个结点，j累加1
- 若到链表末尾p为空，说明第i个结点不存在
- 否则查找成功，在系统中生成一个空结点s
- 将数据元素e赋值给s->data
- 单链表的插入标准语句s->next=p->next；p->next=s；
- 返回成功
Status Listlnsert(LinkList *L,int i,ElemType e) { int j; LinkList p,s; p= *L; j= 1; while(p && j<i) { p=p->next; ++j; } if (!p || j>i)return ERROR; s=(LinkList)malloc(sizeof(LinkList)); s->data=e; s-next=p->next;/*将p的后继结点赋值给s的后继*/ p->next=s;/*将s赋值给p的后继*/ return OK; }
单链表第i个数据删除结点的算法思路
- 声明一个指针p指向链表的头结点，初始化j从1开始
- 当j<i时，就遍历链表，让p指针向后移动，不断指向先一个结点，j累加1
- 若到链表末尾p为空，说明第i个结点不存在
- 否则查找成功，将欲删除的结点p->next赋值给q
- 单链表的删除标准语句p->next=q->next
- 将q结点中的数据赋值给e，作为返回
- 释放q结点
- 返回成功
Status ListDelete(LinkList *L,int i,ElemType *e) { int j; LinkList p,q; p= *L; j= 1; while(p->next && j<i) { p=p->next; ++j; } if (!(p->next) || j>i)return ERROR; q=p->next; p-next=q->next; *e=q->data; free(q); return OK; }
1.4单链表的整表删除
单链表的整表删除算法思路
- 声明一个结点p和q
- 将第一个结点赋值给p
- 循环
-
- 将下一个结点赋值给q；
- 释放p
- 将q赋值给p
Status ClearList(LinkList *L) { LinkList p,q; p=(*L)->next; while(p) { q=p->next; free(p); p=q; } (*L)->next=NULL; return OK; }
2、双链表
在每个结点中除包含数值域外，设置有两个指针域，分别用以指向其前驱结点和后继结点
//双链表结点类型DLinkList的声明如下 typedef struct DLinkList { ElemType data; struct DLinkList *prior; //指向前驱结点 struct DLinkList *next; //指向后继结点 }DLinkList;
2.1双链表的创建
(1)头插法建立双链表
从一个空表开始，读取数组a的元素，生成新结点，将读取的数据放在新结点的数据域中，然后将新结点插入到当前链表的表头，直到结束为止
void CreateDListF(LinkList *&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; if (L->next!=NULL) { L->next->prior=s; } L->next=s; s->prior=L; } }
(2)尾插法建立双链表
从一个空表开始，读取数组a的元素，生成新结点，将读取的数据放在新结点的数据域中，然后将新结点插入到当前链表的尾结点，但是要增加一个尾结点指针r。使他始终指向当前链表的表尾上，直到结束为止
void CreateDListR(LinkList *&L,ElemType a[],int n) { DLinkList *s,*r;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=NULL; }
2.2双链表的基本运算法则
(1)查找指定元素的结点
在双链表中查找第一个data域值为X的结点、从第一个结点开始。变遍历边比较。若找到这样的结点。则返回序列。否则返回0
int Finfnode(DLinkList *L,ElemType X) { LinkList *P=l->next; int i=1; while(p!=NULL&&p->data!=x) { i++; p=p->next; } if (p==NULL)return 0; else return i; }
(2)插入结点操作
s->next=p->next; //将*s插入到*p之后 p->next-prior=s; s->prior=p; p->next=s;
//在双链表L中第i个位置插入值域为e的结点 int Listlnsert(DLinkList *&L,int i,ElemType e) { int j=0; DLinkList *p=L,*s; while(j<i-1 && p!=NULL) //查找第i-1个元素 { j++; p=p->next; } if (p==NULL)return 0; //未找到第i-1个节点 else //找到第i-1个节点 { s=(DLinkList *)malloc(sizeof(DLinkList)); //创建新结点*s s->data=e; s->next=p->next; //将*s插入到*p之后 if (p->next!=NULL) //若存在*p的后继结点。将其前驱指向*s { p->next->prior=s; } s->prior=p; p->next=s; return 1; } }
（3）删除结点操作
p->next=q->next; //删除*p结点后的结点 q->next-prior=p;
//在双链表L中删除第i个结点 int ListDelete(DLinkList *&L,int i,ElemType e) { DLinkList *p=L,*q; int j=0; while(j<i-1 && p!=NULL) //查找第i-1个元素 { j++; p=p->next; } if (p==NULL)return 0; //不存在第i-1个节点 else //找到第i-1个节点*p { q=p->next; //q指向要删除的结点 if (q==NULL)return 0; //不存在第i个结点 p->next=q->next; //从链表中删除*q结点 if (p->next!=NULL) p->next->prior=p; free(q); //释放*q结点 return 1; } }
