数据结构之线性表中的链表--单链表&循环链表（2）

单链表与循环链表详解

原创已于 2025-11-25 22:14:20 修改 · 275 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #链表

于 2025-11-21 23:55:10 首次发布

数据结构专栏收录该内容

3 篇文章

订阅专栏

「C++ 40 周年」主题征文大赛（有机会与C++之父现场交流！） 10w+人浏览 734人参与

链表与线性表的区别：

链表是一种动态管理的存储结构，链表中每个结点占用的存储空间不是预先分配的，而是运行时系统根据需求生成的，不要求逻辑上相邻的元素在内存地址中也相邻，它是通过"链“建立起来的元素之间的逻辑关系，对线性表的插入，删除不需要移动数据元素，显然比顺序表更加的方便。

线性表中链式存储结构的特点是：

用一组任意的存储单元存储线性表的数据元素（存储单元可以是连续的，也可以是不连续的）。为了表示每个元素 $a_{i}$ 与其直接后继元素 $a_{i+1}$ 之间的逻辑关系，对数据元素 $a_{i}$ 来，除了其本身的信息之外，还需要存储一个指示其直接后继的存储位置，这两部分信息构成“结点”。存放数据元素信息的域称为：数据域，存放其后继地址的域称为：指针域。因此，n个元素的线性表通过每个结点的指针域拉成一条“链子”，称为链表。

单链表：

每个结点中只有一个指向后继的指针，所以称之为单链表。

基本操作包括：

1.创建空的线性表并初始化

//线性表的链式存储结构
typedef int ElemType;
typedef struct node {
	ElemType data;
	struct node* next;//用来存放下一个结点的地址
}Node;

//单链表-初始化
Node* initList() {
	Node* head = (Node*)malloc(sizeof(Node));
	head->data = 0;
	head->next = NULL;
	return head;
}

2.求线性表的长度

//单链表-获取链表长度
int listLength(Node* L) {
	Node* p = L->next;
	int len = 0;
	while (p != NULL) {
		p = p->next;
		len++;
	}
	return len;
}

3.遍历线性表

//单链表-遍历
void listNode(Node* L) {
	Node* p = L->next;
	while (p != NULL) {
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

4.插入一个新元素（三种插入方法）

//单链表-插入数据
//1.头插法
void insertHead(Node* L, ElemType e) {
	Node* p = (Node*)malloc(sizeof(Node));//创建一个新结点存放要插入的元素
	//先让新结点指向头节点指向的下一个结点，然后再让头结点指向新结点
	p->data = e;
	p->next = L->next;
	L->next = p;
}
//2.尾插法
//（1）先获取尾结点的地址
Node* getTail(Node* L) {
	Node* p = L;//创建一个新结点存储传入的链表
	while (p->next != NULL) {
		p = p->next;
	}
	return p;//返回尾结点
}
//（2）在链表后面插入元素
Node* insertTail(Node* tail, ElemType e) {
	//传入链表的尾结点和要插入的元素
	Node* p = (Node*)malloc(sizeof(Node));//创建一个新结点用来存储要插入的元素
	p->data = e;
	tail->next = p;
	p->next = NULL;
	return p;//返回链表
}
//3.在指定位置插入元素
int insertpos(Node* L, int pos, ElemType e) {
	//传入链表，要插入元素的位置和要插入元素的位置
	//创建一个新结点用来保存要插入元素位置的前驱结点
	Node* p = L;
	//遍历找到前驱结点
	for (int i = 0; i < pos - 1; i++) {
		p = p->next;
		if (p->next == NULL) {
			return 0;
		}
	}
	//创建一个新结点，实现插入元素
	Node* q = (Node*)malloc(sizeof(Node));
	//将前一个结点的下一个位置赋值给新结点的下一个位置，然后将新结点赋值给前一个结点的next
	q->data = e;
	q->next = p->next;
	p->next = q;
	return 1;
	
}

5.删除一个元素

//单链表-删除结点
/*
1.找到要删除结点的前置结点p
2.用指针q记录要删除的结点
3.通过改变p的后继结点实现删除
3.释放删除结点的空间（因为是在堆内存中创建的）
*/
int deleteNode(Node* L, int pos) {
	//传入链表和要删除链表中结点的位置
	//创建一个新结点用来保存要删除位置元素的前驱结点，通过遍历实现
	Node* p = L;
	for (int i = 0; i < pos - 1; i++) {
		p = p->next;
		if (p->next == NULL) {
			printf("你要删除元素的位置有误！");
			return 0;
		}
	}
	//创建一个新结点用来记录要删除的结点
	Node* q = p->next;
	//p->next = p->next->next;//可以这样写吗？
	p->next = q->next;
	free(q);
	return 1;
}

6.查找指定元素位置

//单链表-查找指定元素位置
int findElem(Node* L, ElemType e) {
	Node* q = L->next;
	int pos = 1;
	//遍历链表
	while (q != NULL) {
		if (q->data == e) {
			return pos;
		}
		q = q->next;
		pos++;
	}
	return 0;
}

7.清空线性表

//单链表-释放链表（头结点之后所有链表释放）
/*操作步骤：
1.指针p指向头结点后的第一个结点
2.判断指针p是否指向空结点
3.如果p不为空，用指针q记录指针p的后继结点
4.释放指针p指向的结点
5.指针p和指针q指向同一个结点，循环上面操作

*/
void freeList(Node* L) {
	Node* p = L->next;
	Node* q;
	while (p != NULL) {
		q = p->next;
		free(p);
		p = q;
	}
	L->next = NULL;
}

实现：

//实现
int main() {
	Node* list = initList();
	//尾插法
	Node* tail = getTail(list);
	tail = insertTail(tail, 10);
	tail = insertTail(tail, 20);
	tail = insertTail(tail, 30);
	tail = insertTail(tail, 40);
	tail = insertTail(tail, 50);
	//遍历
	listNode(list);//10 20 30 40 50
	//头插法
	insertHead(list, 66);
	//遍历
	listNode(list);//66 10 20 30 40 50
	//在指定位置插入元素
	insertpos(list, 2, 88);
	//遍历
	listNode(list);//66 88 10 20 30 40 50
	//删除第三个元素
	deleteNode(list, 3);
	//遍历
	listNode(list);//66 88 20 30 40 50
    //查找指定元素位置
    int find1 = findElem(list,50);
    //判断然后输出
    if (find1 != 0) {
	printf("要查找的元素在链表中第%d个位置\n", find1);//要查找的元素在链表中第6个位置
    }
    else {
	printf("链表中没有该值！\n");
    }
	//获取链表长度
	int len = listLength(list);
	printf("%d\n",len);//6
	//释放链表
	freeList(list);
	//遍历
	listNode(list);
	return 0;
}