线性表
1.线性表的顺序存储
1.1线性表的基本操作
数组基本操作
IninList(&L):初始化表,构造一个空表。
Length(L):求表长,返回线性表长度,机元素个数。
LocationElem(L,i):按值查找操作。
GetElem(L,i):按位查找操作。获取第i个位置的值。
ListInsert(&L,i,e):插入操作,在表中第i个位置插入元素e。
ListDelete(&L,i,&e):删除元素,删除表中第i个位置的元素并将其值返回给e。
PrintList(L):输出操作,按照前后顺序输出表中所有元素的值。
Empty(L):判空操作,判断L是否为空表。
DestroyList(&L):销毁操作,销毁线性表并释放空间。
1.2线性表的定义
1.2.1静态分配
#include<stdio.h>
#define MaxSize 50
typedef struct{
ElemType data[MaxSize];
int length;
//表长
}SqList;
int main(){
return 0;
}
1.2.2动态分配
#include<stdio.h>
#define InitSize 50
typedef struct {
ElemType *data;
//指针指向第一个数据元素
int MaxSize,length;
//数组的最大容量和当前长度
}Sqlist;
int main(){
return 0;
}
1.2.3初始化语句
L.data = (ElemType*)malloc(sizeof(ElemType)*InitSize);
//申请一片内存并将data指针指向其地址段的首地址
1.3基本操作的实现
1.3.1顺序表的初始化
静态
//SqList L;//声明一个顺序表
void InitList(SqList &L){
L.length = 0;
//顺序表初始长度为0
}
动态
//SqList L;
void InitList(SqList &L){
L.data = (int *)malloc(InitSize*sizeof(ElemType));//分配空间
L.length = 0;
L.MaxSize = InitSize;
//初始存储容量
}
1.3.2插入操作
bool ListInsert(SqList &L,int i,ElemType e){
if (i < 1 || i > L.length + 1)
return false;
if (L.length >= MaxSize)
return false;
for (int j = L.length; j >= i; j--)
L.data[j] = L.data[j-1];
L.data[i-1] = e;
L.length ++;
return true;
}
1.3.3删除操作
bool ListDelete(SqList &L,int i,ElemType &e){
if(i < 1 || i > L.length)
return 0;
e = L.data[i-1];
for(int j = i; j < L.length;j++)
L.data[i-1] = L.data[i];
L.length--;
return true;
}
1.3.4按值查找操作
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;
}
2.线性表的链式存储
2.1单链表的定义
typedef struct LNode{
ElemType data; //数据域
struct LNode *next; //指针域,指向下一个结点区域
}LNode,*LinkList;
//或者
struct LNode{
ElemType data; //数据域
struct LNode *next; //指针域,指向下一个结点区域
};
typedef struct LNode LNode;
typedef struct LNode *LinkList;
//定义指向结构体指针
LNode *L;强调指向结点L
LinkList L;强调这是一个单链表L的头指针
2.2单链表的基本操作实现
2.2.1单链表的初始化
//带有头结点
bool InitList(LinkList &L){ // 创建带有头节点的单链表
L = (LNode *)malloc(sizeof(LNode)) //创建一个LNode型的结点并将结点的起始地址赋值给L
L -> next = NULL;
return true;
}
//不带有头结点
bool InitList(LinkList &L){
L = NULL;
return true;
}
2.2.2求表长
int Length(LinkList L){
int len = 0;
LNode *p = L;
while( p->next !- NULL){
p = p -> next;
len ++;
}
return len;
}
2.2.3按序号查找表结点
LNode *GetElem(LinkList L,int i){
LNode *p = L;
int j = 0;
while(p != NULL&&j < i){
p = p->next;
j++;
}
return p;
}
2.2.4按值查找表结点
LNode *LocateElem(LinkList L,ElemType e){
LNode *p = L;
while(p != NULL&&p->data != e){
p = p->next;
}
return p;
}
2.2.5插入结点操作
bool ListInsert(LinkList &L,int i,ElemType e){
LNode *p = L;
int j = 0;
while(p != NULL&&j < i - 1)
P = P->Next;
j++;
}
if(p == NULL){
return false;
}
LNode *s = (LNode *)malloc(sizeof(LNode));
s->data = e;
s->next = p->next;
p->next = s;
return true;
}
扩展:对某一结点进行前插操作
s->next = p->next;
p->next = s;
temp = p->data;
p->data = s->data;
s->data = temp;
2.2.6删除结点操作
bool ListDelete(LinkList &L,int i,ElemType &e){
LNode *p = L;
int j = 0;
while(p!=NULL&&j<i-1){
p = p->next;
j++;
}
if(p == NULL||p->next == NULL)
return false;
LNode *q = p->next;
e = q->data;
p->next = q->next;
free(q);
return true;
}
扩展:删除结点可以用删除后继结点的方式实现
q = p->next;
p->data = p->next->data;
p->next = q->next;
free(q);
2.2.7采用头插法建立单链表
LinkList List_HeadInsert(LinkList &L){
LNode *s;int x;
L = (LNode *)malloc(sizeof(LNode));
L->next = NULL;
scanf("%d",&x);
while(x != 9999){
s = (LNode *)malloc(sizeof(LNode));
s->data = x;
s->next = L->next;
L->next = s;
scanf("%d",&x);
}
}
2.2.7采用尾插法建立单链表
LinkList List_TailInsert(LinkList &L){
int x;
L = (LNode *)malloc(sizeof(LNode));
LNode *s,*r = L;
scanf("%d",&x);
while(x!=9999){
s = (LNode *)malloc(sizeof(LNode));
s->data = x;
r->next = s;
r = s;
scanf("%d",&x);
}
r->next = NULL;
return L; //返回头指针
}
2.3双链表
typedef struct DNode{
ElemType data;
struct DNode *prior,*next;
}DNode,*DLinkList;
2.3.1双链表的插入操作
//在p结点之后插入s结点
s->next = p->next;
p->next->prior = s;
s->prior = p;
p->next = s;
2.3.2双链表的删除操作
//删除p结点之后的q结点
p->next = q->next;
q->next ->prior = p;
free(q);
2.4循环链表
2.4.1循环单链表
将单链表的最后一个结点的指针指向头结点
2.4.2循环双链表
将最后一个结点的尾指针指向头结点,将头结点的首指针指向最后一个节点
2.5静态链表
#define MaxSize 50
typedef struct{
ElemType data;
int next;
}SLinkList[MaxSize];
2.6顺序表和链表的比较
存取方式
1.顺序表可以顺序存取也可以随机存取。
2.链表只能从表头开始顺序存取。
逻辑结构和物理结构
1.顺序存储时,逻辑上相邻的元素物理存储位置也相邻。
2.链式存储时,逻辑关系通过指针链接表示,物理存储位置也不一定相邻。
查找,插入和删除操作
1.按值查找时,顺序表无序时,二者时间复杂度为O(n),,顺序表有序时,采用折半查找的时间复杂度为O(log2n)。
2.按序号查找时,顺序表时间复杂度为O(1),链表平均时间复杂度为O(n)。
3.插入,删除时,顺序表平均移动半个表长,链表仅需要移动相关指针域即可。
空间分配
1.顺序存储在静态存储分配情形下,一旦存储空间装满就不能扩充, 若再加入新元素,则会出现内存溢出,因此需要预先分配足够大的存储空间。预先分配过大,可能会导致顺序表后部大量闲置; 预先分配过小,又会造成溢出。
2.动态存储分配虽然存储空间可以扩充,但需要移动大量元素,导致操作效率降低,而且若内存中没有更大块的连续存储空间,则会导致分配失败。链式存储的结点空间只在需要时申请分配,只要内存有空间就可以分配, 操作灵活、高效。此外,由于链表的每个结点都带有指针域,因此存储密度不够大。
3.实际中选取存储结构
3.1基于存储的考虑
1.难以估计线性表的长度或存储规模时,不宜采用顺序表;
2.链表不用事先估计存储规模,但链表的存储密度较低,显然链式存储结构的存储密度是小于1的。
3.2基于运算的考虑
1.在顺序表中按序号访问a;的时间复杂度为0(1),而链表中按序号访问的时间复杂度为0(n), a因此若经常
做的运算是按序号访问数据元素,则显然顺序表优于链表。
2.在顺序表中进行插入、删除操作时,平均移动表中一半的元素,当数据元素的信息量较大且表较长时,这
一点是不应忽视的;在链表中进行插入、删除操作时,虽然也要找插入位置, 但操作主要是比较操作,
从这个角度考虑显然后者优于前者。
3.3基于环境的考虑
顺序表容易实现,任何高级语言中都有数组类型;链表的操作是基于指针的,相对来讲,前者实现较为简
单,这也是用户考虑的一个因素。
3.4总结
总之,两种存储结构各有长短,选择哪一种由实际问题的主要因素决定。通常较稳定的线性表选择顺序存
储,而频繁进行插入、删除操作的线性表(即动态性较强)宜选择链式存储。