线性表（代码汇总）

原创于 2024-08-13 20:49:31 发布 · 1.4k 阅读

30 ·

CC 4.0 BY-SA版权

文章标签：

#c语言 #数据结构 #算法 #c++ #线性表 #链表

考研数据结构专栏收录该内容

10 篇文章

订阅专栏

线性表

线性表

线性表

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.在顺序表中进行插入、删除操作时，平均移动表中一半的元素，当数据元素的信息量较大且表较长时，这
一点是不应忽视的;在链表中进行插入、删除操作时，虽然也要找插入位置，但操作主要是比较操作,
从这个角度考虑显然后者优于前者。