1. 线性表

最新推荐文章于 2024-08-29 18:01:01 发布
最新推荐文章于 2024-08-29 18:01:01 发布
阅读量246 收藏
点赞数
分类专栏： 数据结构 文章标签： 指针 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45634592/article/details/115024395
版权

文章目录

1.1 线性表的顺序存储

1.1.1 线性表的实现 — 静态分配
功能说明
initSqList(SeqList *L)初始化顺序表
ListInsert(SeqList *L,int i,int e)插入（在顺序表L中的第i个位置插入e）
ListDelete(SeqList *L,int i,int *e)删除(删除顺序表L中的第i个元素并利用传过来的变量 *e 返回删除的数据)
GetElem(SeqList &L,int i)按位查找（查找顺序表L的第i个元素）
LocateElem(SeqList *L, int e)按值查找(在顺序表L中查找e，并返回其位序)
printSeqList(SeqList *L)打印顺序表
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MaxLength 10	// 设置数组的最大长度为 10 

// 定义一个顺序表结构体
typedef struct{
	int data[MaxLength]; 
	int length;		//  记录顺序表当前的长度 
}SeqList;

// 基本功能————初始化顺序表 
void initSeqList(SeqList *L){
	L->length = 0;
} 

// 基本功能————插入（在顺序表L中的第i个位置插入e） 
void ListInsert(SeqList *L,int i,int e){
	if (i<1 || i>L->length + 1){ 
		printf("位序i不合法，插入错误！");
	}else if (L->length >= MaxLength){
		printf("当前存储容量已满，不能插入！");
	}else {
		for(int j = L->length - 1;j >= i - 1;j--)
			L->data[j + 1] = L->data[j];
		L->data[i-1] = e;
		(*L).length++;
		printf("插入成功！\n");
	} 
} 

// 基本功能————删除(删除顺序表L中的第i个元素并利用传过来的变量 *e 返回删除的数据)
int ListDelete(SeqList *L,int i,int *e){
	if (i<1 || i>L->length + 1){ 
		return 0;
	}
	
	*e = L->data[i-1];
	for(int j = i;j<L->length;j++)
		L->data[j-1] = L->data[j];
	(*L).length--;
	return 1;
} 

// 基本功能————按位查找（查找顺序表L的第i个元素） 
int GetElem(SeqList *L,int i){
	if (i<1 || i>L->length + 1){
		printf("不存在该位置的元素！"); 
		return 0;
	}
	return L->data[i - 1];
} 

// 基本功能————按值查找(在顺序表L中查找e，并返回其位序)
int LocateElem(SeqList *L, int e){
	for(int i = 0; i < L->length; i++){
		if(L->data[i] == e)
			return i + 1;
		return 0;
	} 
} 

// 基本功能————打印顺序表 
void printSeqList(SeqList *L){
	// 尝试违规读取顺序表中的所有数据 
//	for(int i = 0;i<MaxLength;i++){
//		printf("data[%d]=%d\n", i, L->data[i]);
//	}
	for(int i = 0;i < L->length;i++){
		printf("data[%d]=%d\n", i, L->data[i]);
	}
}

int main(){
	SeqList L;	// 声明一个顺序表
	initSeqList(&L);	// 初始化顺序表 
	ListInsert(&L,1,100);
	ListInsert(&L,2,98);
	ListInsert(&L,3,50);
	printSeqList(&L);	// 打印顺序表 
	int e = -1;
	if(ListDelete(&L,1,&e) == 1){
		printf("删除的数据为%d\n",e);
	}else{
		printf("位序i不合法，删除错误！");
	}
	
	printf("%d是第%d个数据\n",98,LocateElem(&L , 98));
	
	printSeqList(&L);	// 打印顺序表 
}
1.1.2 线性表的实现 — 动态分配
功能说明
initSeqList(SeqList *L)初始化顺序表
IncreaseSize(SeqList *L, int len)动态添加数组的长度
ListInsert(SeqList *L,int i,int e)插入（在顺序表L中的第i个位置插入e）
ListDelete(SeqList *L,int i,int *e)删除(删除顺序表L中的第i个元素并利用传过来的变量 *e 返回删除的数据)
GetElem(SeqList *L,int i)按位查找（查找顺序表L的第i个元素）
LocateElem(SeqList *L, int e)按值查找(在顺序表L中查找e，并返回其位序)
printSeqList(SeqList *L)打印顺序表
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define InitLength 10	// 设置初始数组的长度为 10 

// 定义一个顺序表结构体
typedef struct {
	int* data;	// 指向动态分配数组的指针 
	int MaxLength;	// 顺序表的最大长度 
	int length;		//  记录顺序表当前的长度 
}SeqList;

// 基本功能————初始化顺序表 
void initSeqList(SeqList *L){
	L->data = (int*)malloc(InitLength * sizeof(int));	// 动态分配数组的空间 (10个)
	L->length = 0;
	L->MaxLength = InitLength;
} 

// 动态添加数组的长度
void IncreaseSize(SeqList *L, int len){
	int* p = L->data;	// 定义一个指针 p 指向指针 data 所指向的位置 
	L->data = (int*)malloc((L->MaxLength+len)*sizeof(int));	// 分配新的内存空间，并让指针 data 指向它
	for(int i = 0 ; i < L->length ; i++){
		// L->data[i] = p[i];	// 将数据复制到新区域 
		*(L->data+i) = *(p + i);	// 与上面的一句话是等价的
		// 理解：
		// 数组 a[] 中 a 就是一个指针，一个指向数组首地址的不能更改的常量指针
		// 所以当一个指针指向数组后，那么相当于这个数组有了一个新的名字
		// 即 a[] 等价于 p[] 
	} 
	L->MaxLength += len;
	free(p);
} 

// 基本功能————插入（在顺序表L中的第i个位置插入e） 
void ListInsert(SeqList *L,int i,int e){
	if (i<1 || i>L->length + 1){ 
		printf("位序i不合法，插入错误！");
	}else if (L->length >= L->MaxLength){
		printf("当前存储容量已满，不能插入！");
	}else {
		for(int j = L->length - 1;j >= i - 1;j--)
			L->data[j + 1] = L->data[j];
		L->data[i-1] = e;
		(*L).length++;
		printf("插入成功！\n");
	} 
} 

// 基本功能————删除(删除顺序表L中的第i个元素并利用传过来的变量 *e 返回删除的数据)
int ListDelete(SeqList *L,int i,int *e){
	if (i<1 || i>L->length + 1){ 
		return 0;
	}
	
	*e = L->data[i-1];
	for(int j = i;j<L->length;j++)
		L->data[j-1] = L->data[j];
	(*L).length--;
	return 1;
} 

// 基本功能————按位查找（查找顺序表L的第i个元素）
int GetElem(SeqList *L,int i) {
	if (i<1 || i>L->length + 1){ 
		return 0;
	}
	return L->data[i - 1];
}

// 基本功能————按值查找(在顺序表L中查找e，并返回其位序)
int LocateElem(SeqList *L, int e){
	for(int i = 0; i < L->length; i++){
		if(L->data[i] == e)
			return i + 1;
		return 0;
	} 
} 

// 基本功能————打印顺序表 
void printSeqList(SeqList *L){
	// 尝试违规读取顺序表中的所有数据 
//	for(int i = 0;i<L->MaxLength;i++){
//		printf("data[%d]=%d\n", i, L->data[i]);
//	}
	for(int i = 0;i < L->length;i++){
		printf("data[%d]=%d\n", i, L->data[i]);
	}
}

int main(){
	SeqList L;	// 声明一个顺序表
	initSeqList(&L);	// 初始化顺序表 
	IncreaseSize(&L , 5);	// 扩容
	
	ListInsert(&L , 1 , 123);	// 插入数据 
	ListInsert(&L , 2 , 78);
	ListInsert(&L , 3 , 98);
	
	int e = -1;	// 删除元素
	ListDelete(&L , 2 , &e);
	printf("删除的元素是：%d\n", e);
	 
	printSeqList(&L);	// 打印顺序表 
}

1.2 线性表的链式存储

1.2.1 单链表
1.2.1.1 带头节点的单链表
功能说明
InitList(LinkList *L)初始化**（有区别）**
Empty(LinkList L)判断单链表是否为空**（有区别）**
ListInsert(LinkList L, int i, int e)按位序插入（在 L 的第 i 个节点插入元素 e）（有区别）
ListDelete(LinkList L, int i)按位序删除（删除表 L 中的第 i 个节点的元素）（有区别）
GetElem(LinkList L, int i)按位查找（返回表 L 中的第 i 个节点的元素）（有区别）
LocateElem(LinkList L, int e)按值查找（返回表 L 中的存储着e的元素）（有区别）
Length(LinkList L)求表的长度**（有区别）**
PrintList(LinkList L)打印单链表
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct LNode{	// 定义一个单链表的节点类型 
	int data;	// 每个节点的数据域 
	struct LNode* next;	// 每个节点的指针域，指针指向下一个节点 
}LNode, *LinkList;
// LNode* 强调的是节点		LinkList 强调的是单链表 

// 初始化（带头节点）
void InitList(LinkList *L){ 
	*L = (LNode*)malloc(sizeof(LNode));	// 分配一个头节点 （头节点是不存储数据的）
	if(*L == NULL){
		printf("分配空间失败！\n");
	}else{
		(*L)->next = NULL;
		printf("分配空间成功！\n");
	}
}

// 判断单链表是否为空（带头节点） 
void Empty(LinkList L){
	if (L->next == NULL){
		printf("单链表为空！\n");
	}else{
		printf("单链表不为空！\n");
	}
}

// 按位序插入（带头节点）
// 在 L 的第 i 个节点插入元素 e 
void ListInsert(LinkList L, int i, int e){
	// 如果要插入的位置小于1则报错 
	if(i<1){
		printf("位序i不合法，插入错误！");
		exit(1); 
	}
	LNode* p = L;	// 指针p指向当前扫描到的节点（初始化指向第一个节点） 
	int j = 0; 	// 记录当前p指向的是第几个节点
	
	while(p != NULL && j < i - 1){	// 找到插入的位置 
		p = p->next;
		j++;
	} 
	
	// 如果要插入的位置大于 L 的实际长度，则报错 
	if (p == NULL){
		printf("位序i不合法，插入错误！");
		exit(1);
	} 
	LNode* s = (LNode*)malloc(sizeof(LNode)); 
	if (s == NULL){
		printf("分配空间失败！！！");
		exit(1); 
	}
	s->data = e;	// 插入元素 
	s->next = p->next;
	p->next = s;
	printf("插入成功！\n");
} 

// 按位序删除（带头节点）
// 删除表 L 中的第 i 个节点的元素
void ListDelete(LinkList L, int i){
	// 如果要删除的位置小于1则报错 
	if(i<1){
		printf("位序i不合法，删除错误！");
		exit(1); 
	}
	LNode* p = L;	// 指针p指向当前扫描到的节点（初始化指向第一个节点） 
	int j = 0; 	// 记录当前p指向的是第几个节点
	
	while(p != NULL && j < i - 1){	// 找要删除的元素的前一个节点 
		p = p->next;
		j++;
	} 
	
	// 如果要删除的位置大于 L 的实际长度，则报错 
	if (p == NULL || p->next == NULL){
		printf("位序i不合法，删除错误！");
		exit(1);
	}
	
	LNode* q = p->next; 	// 定义一个指针指向要删除的节点
	p->next = q->next;
	free(q); 
	printf("删除成功！\n");
} 

// 按位序查找（带头节点）
// 返回表 L 中的第 i 个节点的元素
LNode* GetElem(LinkList L, int i){
	// 如果要查找的位置小于1则报错 
	if(i<1){
		printf("查找的位置不正确！");
		exit(1); 
	}
	LNode* p = L;	// 指针p指向当前扫描到的节点（初始化指向第一个节点） 
	int j = 0; 	// 记录当前p指向的是第几个节点
	
	while(p != NULL && j < i){	// 找到第i个节点 
		p = p->next;
		j++;
	} 
	return p;
} 

// 按值查找（带头节点）
// 返回表 L 中的存储着e的元素
LNode* LocateElem(LinkList L, int e){
	LNode* p = L->next;	// 指针p指向第一个节点 
	
	while(p != NULL && p->data != e){	// 当找到或未找到（p指向NULL）时停下 
		p = p->next;
	} 
	return p;
} 

// 求表的长度（带头节点）
int Length(LinkList L){
	int len = 0;
	LNode* p = L;
	while(p->next != NULL){
		p = p->next;
		len++;
	}
	return len;
} 

// 打印单链表
void PrintList(LinkList L){
	LNode* p = L->next;		// p指向实际存储数据的第一个节点 
	while(p != NULL){
		printf("%d\n",p->data);
		p = p->next; 
	}
} 

void main(){
	LinkList L;		// 声明一个指向单链表的指针
	InitList(&L); 
	
	Empty(L); 
	ListInsert(L ,1 ,78);
	ListInsert(L ,2 ,48);
	ListInsert(L ,3 ,12345);
	
	PrintList(L);
	ListDelete(L ,2);
	PrintList(L);
	
}
1.2.1.2 不带头结点的单链表
功能说明
InitList(LinkList *L)初始化**（有区别）**
Empty(LinkList L)判断单链表是否为空**（有区别）**
ListInsert(LinkList L, int i, int e)按位序插入（在 L 的第 i 个节点插入元素 e）（有区别）
PrintList(LinkList L)打印单链表
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct LNode{	// 定义一个单链表的节点类型 
	int data;	// 每个节点的数据域 
	struct LNode* next;	// 每个节点的指针域，指针指向下一个节点 
}LNode, *LinkList;
// LNode* 强调的是节点		LinkList 强调的是单链表 

// 初始化（不带头节点） 
void InitList(LinkList *L){
	*L = NULL;	// 空表，没有任何节点 
}

// 判断单链表是否为空（不带头节点） 
int Empty(LinkList L){
	if (L == NULL){
		printf("单链表为空！");
	}else{
		printf("单链表不为空！");
	}
} 

// 按位序插入（不带头节点） 
// 在 L 的第 i 个节点插入元素 e 
void ListInsert(LinkList* L, int i, int e){
	// 如果要插入的位置小于1则报错 
	if(i<1){
		printf("位序i不合法，插入错误！");
		exit(1); 
	}else if(i == 1){
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = *L;
		*L = s;
		printf("插入成功！\n");
		return;
	} 
	LNode* p = *L;	// 指针p指向当前扫描到的节点（初始化指向第一个节点） 
	int j = 1; 	// 记录当前p指向的是第几个节点
	
	while(p != NULL && j < i - 1){	// 找到插入的位置 
		p = p->next;
		j++;
	} 
	
	// 如果要插入的位置大于 L 的实际长度，则报错 
	if (p == NULL){
		printf("位序i不合法，插入错误！");
		exit(1);
	} 
	LNode* s = (LNode*)malloc(sizeof(LNode)); 
	if (s == NULL){
		printf("分配空间失败！！！");
		exit(1); 
	}
	s->data = e;	// 插入元素 
	s->next = p->next;
	p->next = s;
	printf("插入成功！!\n");
} 

// 打印单链表
void PrintList(LinkList L){
	while(L != NULL){
		printf("%d\n",L->data);
		L = L->next; 
	}
} 

void main(){
	LinkList L;		// 声明一个指向单链表的指针
	InitList(&L); 
	
	ListInsert(&L ,1 ,78);
	ListInsert(&L ,2 ,48);
	ListInsert(&L ,3 ,12345);
	
	PrintList(L);
}
1.2.1.3 前插操作

没有区别 带/不带 头节点都适用

// 前插操作：在p节点之前插入元素e
void InsertPriorNode(LNode* p, int e){
	if (p == NULL){
		printf("插入失败！");
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL){
		printf("分配空间失败！");
	} 
	s->data = p->data;
	s->next = p->next;
	p->next = s;
	p->data = e;
	printf("插入成功！\n");
}
1.2.1.4 后插操作

没有区别 带/不带 头节点都适用

// 后插操作：在p节点之后插入e 
void InsertNextNode(LNode* p, int e){
	if (p == NULL){
		printf("插入失败！");
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL){
		printf("分配空间失败！");
	} 
	s->data = e;
	s->next = p->next;
	p->next = s;
	printf("插入成功！\n");
}
1.2.1.5 删除指定节点（有bug）

如果删除的是最后一个节点的话，将会无法删除（程序不会报错，但也不会达到预期目的）

（可能会想，我单独将这一种情况进行判断不就好了吗？注意：删除最后一个节点，就是将该节点的前驱指向NULL，请问能实现吗？（直接free掉最后一个节点是不行的））

// 删除指定的节点
void DeleteNode(LNode* p){
	if (p == NULL){
		printf("删除失败！\n");
	}
	LNode* q = p->next;		// 定义一个指针q指向要删除的节点的后继节点 
	p->data = q->data;		// 将后继节点的数据赋值给要删除的节点 
	p->next = q->next;		// 让要删除的节点指向后继节点的后继节点
	free(q);	// 释放后继节点的存储空间 
	printf("删除成功！\n"); 
}
1.2.1.6 单链表的建立

1.2.1.6.1 头插法

LinkList CreatListHead(){
	LinkList L = (LNode*)malloc(sizeof(LNode));		// 头节点
	if (L == NULL){
		printf("分配空间失败！！！");
		exit(1); 
	} 
	L->next = NULL;	// 如果不初始化，可能会有脏数据，即指向一个未知的区域 
	LNode* s;	// 用于暂存需要添加的数据 
	int x = 0;
	printf("请输入你想要添加的数据：");
	scanf("%d", &x); 
	while(x != 9999){	// 输入9999表示结束 
		s = (LNode*)malloc(sizeof(LNode)); 
		if (s == NULL){
			printf("分配空间失败！！！");
			exit(1); 
		} 
		s->data = x;
		s->next = L->next;
		L->next = s;
		printf("请输入你想要添加的数据：");
		scanf("%d", &x);
	}
	return L;
}

1.2.1.6.2 尾插法

LinkList CreatListTail(){
	LinkList L = (LNode*)malloc(sizeof(LNode));		// 头节点
	if (L == NULL){
		printf("分配空间失败！！！");
		exit(1); 
	} 
	L->next = NULL;	// 初始化 
	LNode* s;	// 用于暂存需要添加的数据 
	LNode* r = L;	// r永远指向尾部，即尾指针
	int x = 0;
	printf("请输入你想要添加的数据：");
	scanf("%d", &x); 
	while(x != 9999){	// 输入9999表示结束 
		s = (LNode*)malloc(sizeof(LNode)); 
		if (s == NULL){
			printf("分配空间失败！！！");
			exit(1); 
		} 
		s->data = x;
		s->next = r->next;
		r->next = s;
		r = s;	// 尾指针指向最后一个节点
		printf("请输入你想要添加的数据：");
		scanf("%d", &x);
	}
	return L;
}
1.2.2 双链表
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct DNode{	// 定义一个双链表的节点类型 
	int data;	// 每个节点的数据域 
	struct DNode* prior,* next;	// 前驱和后继指针 
}DNode, *DLinkList;

// 初始化（带头节点）
void DInitList(DLinkList *L){ 
	*L = (DNode*)malloc(sizeof(DNode));	// 分配一个头节点 （头节点是不存储数据的）
	if(*L == NULL){
		printf("分配空间失败！\n");
	}else{
		(*L)->next = NULL;
		(*L)->prior = NULL;
		printf("分配空间成功！\n");
	}
}

// 判断双链表是否为空（带头节点） 
void Empty(DLinkList L){
	if (L->next == NULL){
		printf("单链表为空！\n");
	}else{
		printf("单链表不为空！\n");
	}
}

// 按位序插入（带头节点）
// 在 L 的第 i 个节点后插入元素 e 
void DListInsert(DLinkList L, int i, int e){
	// 如果要插入的位置小于1则报错 
	if(i<1){
		printf("位序i不合法，插入错误！");
		exit(1); 
	}
	DNode* p = L;	// 指针p指向当前扫描到的节点（初始化指向第一个节点） 
	int j = 0; 	// 记录当前p指向的是第几个节点
	
	while(p != NULL && j < i - 1){	// 找到插入的位置 
		p = p->next;
		j++;
	} 
	
	// 如果要插入的位置大于 L 的实际长度，则报错 
	if (p == NULL){
		printf("位序i不合法，插入错误！");
		exit(1);
	} 
	DNode* s = (DNode*)malloc(sizeof(DNode)); 
	if (s == NULL){
		printf("分配空间失败！！！");
		exit(1); 
	}
	s->data = e;
	s->next = p->next;	// 插入元素 
	if(p->next != NULL)
		p->next->prior = s->next;
	s->prior = p->next;
	p->next = s;
	printf("插入成功！\n");
} 

// 按位序删除（带头节点）
// 删除表 L 中的第 i 个节点的元素
void DListDelete(DLinkList L, int i){
	// 如果要删除的位置小于1则报错 
	if(i<1){
		printf("位序i不合法，删除错误！");
		exit(1); 
	}
	DNode* p = L;	// 指针p指向当前扫描到的节点（初始化指向第一个节点） 
	int j = 0; 	// 记录当前p指向的是第几个节点
	
	while(p != NULL && j < i - 1){	// 找要删除的元素的前一个节点 
		p = p->next;
		j++;
	} 
	
	// 如果要删除的位置大于 L 的实际长度，则报错 
	if (p == NULL || p->next == NULL){
		printf("位序i不合法，删除错误！");
		exit(1);
	}
	
	DNode* q = p->next; // 定义一个指针指向要删除的节点
	p->next = q->next;
	if(q->next!=NULL){
		p->next->prior = p;
	}
	free(q); 
	printf("删除成功！\n");
} 

// 打印双链表
void DPrintList(DLinkList L){
	DNode* p = L->next;		// p指向实际存储数据的第一个节点 
	while(p != NULL){
		printf("%d\n",p->data);
		p = p->next; 
	}
} 

void main(){
	DLinkList L;	// 声明一个指向双链表的指针
	DInitList(&L); 
	
	DListInsert(L ,1 ,78);
	DListInsert(L ,2 ,48);
	DListInsert(L ,3 ,12345);
	
	DPrintList(L);
	DListDelete(L ,2);
	DPrintList(L);
	
}
1.2.3 双向链表
1.2.3.1 循环单链表
#include <stdio.h>
#include <stdlib.h>

typedef struct LNode {    // 定义一个单链表的节点类型
    int data;    // 每个节点的数据域
    struct LNode *next;    // 每个节点的指针域，指针指向下一个节点
} LNode, *LinkList;

// 初始化循环单链表（带头节点）
void InitList(LinkList *L) {
    *L = (LNode *) malloc(sizeof(LNode));    // 分配一个头节点 （头节点是不存储数据的）
    if (*L == NULL) {
        printf("分配空间失败！\n");
    } else {
        (*L)->next = *L;
        printf("分配空间成功！\n");
    }
}

// 判断循环单链表是否为空（带头节点）
void Empty(LinkList L) {
    if (L->next == L) {
        printf("单链表为空！\n");
    } else {
        printf("单链表不为空！\n");
    }
}

// 求表的长度（带头节点）
int Length(LinkList L) {
    int len = 0;
    LNode *p = L;
    while (p->next != L) {
        p = p->next;
        len++;
    }
    return len;
}

// 按位序插入（带头节点）
// 在 L 的第 i 个节点插入元素 e
void ListInsert(LinkList L, int i, int e) {
    // 如果要插入的位置小于1或者超出最大长度则报错
    if (i < 1) {
        printf("位序i不合法，插入错误！");
        exit(1);
    }

    if (i == 1) {
        LNode *s = (LNode *) malloc(sizeof(LNode));
        if (s == NULL) {
            printf("分配空间失败！！！");
            exit(1);
        }
        s->data = e;    // 插入元素
        s->next = L;
        L->next = s;
        printf("插入成功！\n");
    } else {
        LNode *p = L->next;    // 指针p指向当前扫描到的节点（初始化指向第一个节点）
        int j = 1;    // 记录当前p指向的是第几个节点

        while (p != L && j < i - 1) {    // 找到插入的位置
            p = p->next;
            j++;
        }

        // 如果要插入的位置大于 L 的实际长度，则报错
        if (p == L) {
            printf("位序i超过了循环单链表的最大长度，插入错误！");
            exit(1);
        }

        LNode *s = (LNode *) malloc(sizeof(LNode));
        if (s == NULL) {
            printf("分配空间失败！！！");
            exit(1);
        }
        s->data = e;    // 插入元素
        s->next = p->next;
        p->next = s;
        printf("插入成功！\n");
    }
}

// 按位序删除（带头节点）
// 删除表 L 中的第 i 个节点的元素
void ListDelete(LinkList L, int i) {
    // 如果要删除的位置小于1则报错
    if (i < 1) {
        printf("位序i不合法，删除错误！");
        exit(1);
    }
    LNode *p = L->next;    // 指针p指向当前扫描到的节点（初始化指向第一个节点）
    int j = 1;    // 记录当前p指向的是第几个节点

    while (p != L && j < i - 1) {    // 找要删除的元素的前一个节点
        p = p->next;
        j++;
    }

    // 如果要删除的位置大于 L 的实际长度，则报错
    if (p == L) {
        printf("位序i不合法，删除错误！");
        exit(1);
    }

    LNode *q = p->next;    // 定义一个指针指向要删除的节点
    p->next = q->next;
    free(q);
    printf("删除成功！\n");
}

// 按位序查找（带头节点）
// 返回表 L 中的第 i 个节点的元素
LNode *GetElem(LinkList L, int i) {
    // 如果要查找的位置小于1则报错
    if (i < 1) {
        printf("查找的位置不正确！");
        exit(1);
    }
    LNode *p = L->next;    // 指针p指向当前扫描到的节点（初始化指向第一个节点）
    int j = 1;    // 记录当前p指向的是第几个节点

    while (p != L && j < i) {    // 找到第i个节点
        p = p->next;
        j++;
    }
    return p;
}

// 按值查找（带头节点）
// 返回表 L 中的存储着e的元素
LNode *LocateElem(LinkList L, int e) {
    LNode *p = L->next;    // 指针p指向第一个节点

    while (p != L && p->data != e) {    // 当找到或未找到（p指向NULL）时停下
        p = p->next;
    }
    return p;
}

// 打印循环单链表
void PrintList(LinkList L) {
    LNode *p = L->next;        // p指向实际存储数据的第一个节点
    while (p != L) {
        printf("%d\n", p->data);
        p = p->next;
    }
}

void main() {
    LinkList L;        // 声明一个指向单链表的指针
    InitList(&L);

    Empty(L);
//    ListDelete(L, 1);   // 按位序删除
    ListInsert(L, 1, 78);
    ListInsert(L, 2, 48);
    ListInsert(L, 2, 12345);
    printf("%d\n", Length(L));
    printf("%d\n", LocateElem(L, 12345)->data);     // 按值查找
    printf("第2个元素为：%d\n", GetElem(L, 2)->data);  // 安位序查找

    PrintList(L);
    ListDelete(L, 2);   // 按位序删除
    PrintList(L);
}
1.2.3.2 循环双链表

1.3 线性表的销毁

如果线性表是用数组实现的，那么将不需要手动回收，系统会自动回收。

如果线性表是使用了malloc函数实现的，那么将需要手动回收（free函数）。

BUG_GUB
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
4.线性表
weixin_45576327的博客
02-16 666
线性表的定义和特点 一.线性表的定义 在所有的数据结构中最简单的是线性表(linear list)。通常，定义线性表为n(n≥0)个数据元素的一个有限序列。记为 L=(a1,…,ai,ai+1,…,an) 其中，L是表名，ai是表中的数据元素，是不可再分割的原子数据，亦称为结点或表项。n是表中元素的个数，也称为表的长度，若n=0叫做空表，此时，表中一个元素都没有。线性表的第一个元素称为表头(h...
1.线性表.cpp
03-28
1.线性表.cpp
2.线性表的顺序表示
知其然，知其所以然
03-11 863
1.线性表的内容有哪些？（What） 2.为什么要学线性表? ? (Why) 3.如何更好的学习线性表? ? ？(How)
【Ⅱ线性表】1.线性表的定义和基本操作
Aspect of Twilight的博客
11-30 698
目录 前言 一、线性表的定义 1.引例 2.定义 3.非空的线性表或线性结构的特点 4.注解 5.例子 二、线性表的存储结构 1.顺序表、链表 顺序表 链表 2.顺序存储与链式存储的比较 顺序表 链表 三、线性表的基本操作 1.基本操作 2.注解 前言 从今天开始，我们就要开始学习第一个数据结构—线性表了。在此之前，我向大家推荐一下学习数据结构的三步走方法，该方法可以适用于之后的任何一种数据结构的学习。 第一步：逻辑结构 首先需要知道该数据结构的逻辑关系（比如线性
6.线性表（1）
qq_41627390的博客
06-17 201
02.线性表
周太郎的博客
08-02 728
一、线性表的基本概念 1.线性表的定义 线性表是一个具有相同特性的数据元素的有限序列。 相同特性：所有元素属于同一数据类型。 有限：数据元素个数有限。 序列：数据元素由逻辑序号唯一确定。一个线性表中可以有相同值的元素。 线性表中所有元素的个数叫做线性表的长度，用n表示，n大于等于0。n等于0时，表示线性表是一个空表，即不包含任何元素。 2.线性表...
三.线性表
wcy16090127的博客
09-22 830
一.线性表的定义     1.线性表是一个具有相同特性的数据元素的有限序列。     2.线性表中所含元素的个数叫做线性表的长度，用n表示，n≥0。n=0时，表示线性表是一个空表，即表中不包含任何元素。     3.线性表的逻辑表示为：(a1，a2，…，ai，ai+1，…，an)     4.线性表是客观事物的抽象。 二.线性表的运算 1.线性表的9个基本运算：
数据结构.线性表（1）
2301_79724443的博客
01-13 462
一、线性表的定义和特点 说白了就像一个数组。 例子： a： b: 逻辑特征： 由以上关于线性表的特点，笔者认为和数组的特点相差不多，接下来为大家引入一些案例 会浪费空间，那么可以采用下面的方法：只保存有数据项 二、线性表的类型定义 三、基本操作 四、线性表的顺序存储表示
3148. 线性表比较
Cuibaby的博客
04-21 638
单点时限: 2.0 sec 内存限制: 256 MB 设 A=(a0,a1,…,am−1) 和 B=(b0,b1,…,bn−1) 是两个给定的线性表，它们的节点个数分别是 m 和 n，且节点值都是整数。 若 m=n，且 ai=bi (0≤i≤m−1), 则 A=B。 若 m<n，且 ai=bi (0≤i≤m−1)，则 A<B。 若存在一个 j(j<m,j<n)，且 ai=b...
线性表L=(a1，a2,……an)，下列说法正确的是（ ）。** A．每个元素都有一个直接前驱和一个直接后继 B．线性表中至少有一个元素 C．表中诸元素的排列必须是由小到大或由大到小 D．
集众人智慧，少走弯路，用对方法，事半功倍。祝考研成功，风里雨里，学长学姐，长理等你！
04-22 546
D．除第一个和最后一个元素外，其余每个元素都有一个且仅有一个直接前驱和直接后继。809数据结构和908数据结构与算法_练习 第2章 线性表。C．表中诸元素的排列必须是由小到大或由大到小。A．每个元素都有一个直接前驱和一个直接后继。B．线性表中至少有一个元素。
2.线性表
WX公众号-小白学安全
06-15 268
线性表 线性表的定义——零个或多个数据元素的有限序列 线性表特点： 数据元素之间是有序的 数据元素之间是一对一的关系 有限性（线性表的数据元素个数是有限的） 注意：零个数据元素的有限序列被称为空表 线性表的数据元素个数是有限的 线性表的抽象数据类型 ADT 线性表（List） Data 1、线性表数据元素是一个集合{a_1,a_2,a_3....,a_n},数据元素的类型 DataType（int，char,自定义） 2、前驱——除了第一个元...
2.线性表.ppt
09-02
1. **顺序存储**：在顺序表中，数据元素在内存中是连续存储的，这通常通过数组实现。数组的每个元素在内存中占有固定大小的空间，通过下标可以直接访问任意元素，具有良好的存取效率。但在进行插入和删除操作时，...
2.线性表子系统借鉴.pdf
12-17
1. **结构体定义**：`linnode` 结构体用于描述单链表的节点，包含一个字符型数据 `data` 和一个指向下一个节点的指针 `next`。 2. **链表操作**： - **创建线性表**：`CreateList()` 函数通过用户输入创建链表，当...
4.线性表顺序存储结构.pdf
05-21
对于顺序存储结构的线性表，它的最大特点就是可以直接通过下标来访问任何一个元素，这样的操作时间复杂度为O(1)，也就是说访问效率非常高。 接下来，文件中定义了一个顺序存储结构的数据类型`SqList`，它是一个...
【数据结构】—— 树和二叉树
mist的博客
08-26 1427
树和二叉树、堆（顺序结构）、二叉树链式结构
数据结构：用栈实现队列（232）LeetCode
2303_81073778的博客
08-26 760
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1608
数据结构-时间、空间复杂度-详解
浅谈【数据结构】树与二叉树之哈夫曼树
weixin_67526434的博客
08-26 967
浅谈【数据结构】树与二叉树之哈夫曼树
【数据结构】-----哈希
最新发布
m0_73470633的博客
08-29 621
一文看懂哈希结构！
1．线性表的基本操作及应用 ①创建 ②插入 ③删除 ④查找 ⑤应用C++代码
06-07
以下是基于数组实现的线性表的基本操作及应用的 C++ 代码示例： ```c++ #include <iostream> #define MAXSIZE 100 // 线性表最大长度 using namespace std; typedef struct { int data[MAXSIZE]; // 数组存储元素，从下标 1 开始存储 int length; // 线性表当前长度 } SqList; // 初始化线性表 void InitList(SqList &L) { L.length = 0; } // 插入元素 bool InsertList(SqList &L, int i, int x) { if (i < 1 || i > L.length + 1 || L.length >= MAXSIZE) { return false; } for (int j = L.length; j >= i; j--) { L.data[j + 1] = L.data[j]; } L.data[i] = x; L.length++; return true; } // 删除元素 bool DeleteList(SqList &L, int i) { if (i < 1 || i > L.length) { return false; } for (int j = i; j < L.length; j++) { L.data[j] = L.data[j + 1]; } L.length--; return true; } // 查找元素 int SearchList(SqList L, int x) { for (int i = 1; i <= L.length; i++) { if (L.data[i] == x) { return i; } } return -1; } // 输出线性表 void PrintList(SqList L) { for (int i = 1; i <= L.length; i++) { cout << L.data[i] << " "; } cout << endl; } int main() { SqList L; InitList(L); InsertList(L, 1, 1); InsertList(L, 2, 2); InsertList(L, 3, 3); PrintList(L); DeleteList(L, 2); PrintList(L); int pos = SearchList(L, 3); cout << "3 is at position " << pos << endl; return 0; } ``` 以上代码实现了线性表的创建、插入、删除、查找等基本操作，并提供了一个输出线性表的函数。在 main 函数中，首先创建了线性表 L，然后插入了三个元素，输出线性表，接着删除了第二个元素，再次输出线性表，最后查找元素 3 在线性表中的位置，并输出结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BUG_GUB

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值