【数据结构|单循环链表】单循环链表大部分基本操作总结（严蔚敏数据结构）

爱喝冰红茶的方舟

已于 2023-04-27 19:41:43 修改

阅读量1.2k

点赞数 4

分类专栏：数据结构文章标签：数据结构链表考研

于 2023-04-27 18:47:54 首次发布

本文链接：https://blog.csdn.net/weixin_55832952/article/details/130411159

版权

数据结构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

0、介绍

本文基本涵盖了单循环链表的大部分基本操作，与严蔚敏数据结构内容大致贴合，且大部分函数取名结合STL，可结合来学习，可直接最后跳转完整代码复制，代码运行没问题（截图省了）有问题欢迎交流。
说明：数据结构考研&复习，由于基础一般且C++STL还没深入学习，目前全程看的都是鲍松山老师的C语言数据结构实现，非常细致，十分感谢老师。
B站视频链接：【鲍松山-数据结构C语言版（最全的严蔚敏数据结构-代码完全实现）】

一、详细操作实现（代码）

1.0 结构体定义

定义好节点和循环链表结构体

typedef struct Node
{
	ElemType data;
	struct Node *next;
}Node, *PNode;

typedef struct List
{
	PNode first;//首
	PNode last;//尾
	int   size;
}List;

1.00 初始化

循环起来：尾后继为首

void InitSCList(List *list)
{
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	list->first = list->last = s;
	list->last->next = list->first;
	list->size = 0;
}

1.000 申请（“购买”）节点

就是申请节点，务必后继先置空；

Node* _buynode(ElemType x)
{
	Node* s = (Node*)malloc(sizeof(Node));
	assert(s != NULL);
	s->data = x;
	s->next = NULL;
	return s;
}

1.1 单循环链表表尾插入数

function:尾部插入
1.“购买”节点s,链接在尾部;
2.修改last指向;
3.插入的节点next域指向头;
4.循环链表长度++;

void push_back(List* list, ElemType x)
{
	Node* s = _buynode(x);
	list->last->next = s;
	list->last = s;
	s->next = list->first;
	list->size++;
}

1.2 单循环链表表头插入数

function:头部插入
1.“购买”节点s,链接在list->first的next;
2.list->first的next用s->next保存下来;
3.s赋值给list->first->next;
4.判断是否是第一个节点，如果是list->last指向s(当前最后一个);

void push_front(List* list, ElemType x)
{
	Node* s = _buynode(x);
	s->next = list->first->next;
	list->first->next = s;
	if (list->first == list->last)
	{
		list->last = s;
	}
	list->size++;
}

1.3 展示单循环链表

function:列出循环链表;
注意：结束条件不是next域为空了

void show_list(List* list)
{
	Node* p = list->first->next;
	while (p != list->first)
	{
		printf("%d-->", p->data);
		p = p->next;
	}
	printf("Nul.\n");
}

1.4 尾部删除数据

function:尾部删除
1.边界条件判断，等于0没有节点;
2.寻找到last的前驱;
3.释放当前last，把找到的前驱作为last，last->next = first继续循环起来;
4.循环链表长度–;

void pop_back(List* list)
{
	if (list->size == 0)
		return;

	Node* p = list->first;
	while (p->next != list->last)
	{
		p = p->next;
	}

	free(list->last);
	list->last = p;
	list->last->next = list->first;
	list->size--;
}

1.5 头部删除数据

function:头部删除
1.边界条件判断，等于0没有节点;
2.寻找到当前第一个节点，当前第一个节点的后继节点作为first的后继节点，释放第一个节点即可;
3.如果释放的是最后一个节点，连起来;
4.循环链表长度–;

void pop_front(List* list)
{
	if (list->size == 0)
		return;
	Node* p = list->first->next;
	list->first->next = p->next;
	free(p);
	if (list->size == 1)
	{
		list->last = list->first;
	}
	list->size--;
}

1.6 插入元素按照升序

function:按值插入(默认升序);
1.循环判断没到last且值都比x小一直后移;
2.到了最后还是没找到比x大，尾插;
3.否则插在p的后面且长度++;

void insert_val(List* list, ElemType x)
{
	Node* p = list->first;
	while (p->next != list->last && p->next->data < x)
	{
		p = p->next;
	}

	if (p->next == list->last && p->next->data < x)
	{
		push_back(list, x);
	}
	else
	{
		Node* s = _buynode(x);
		s->next = p->next;
		p->next = s;
		list->size++;
	}
}

1.7 查找元素所在位置，没有返回-1

需要注意先判空，其他就遍历

Node* find(List* list, ElemType key)
{
	if (list->size == 0)
		return NULL;

	Node* p = list->first->next;
	while (p != list->first && p->data != key)
		p = p->next;

	if (p == list->first)
		return NULL;
	return p;
}

1.8 返回长度

有了结构体，否则就从first到last来计数

int  length(List* list)
{
	return list->size;
}

1.9 删除某个指定元素(第一次出现)

function:删除某个指定元素(第一次出现);
1.判断长度，为0没得删，不为0就寻找这个元素;
2.在尾部用尾删即可;
3.我们删除用“替换”代替，只要把要删除的节点数据域记住，后继连好删除哪个都行;

void delete_val(List* list, ElemType key)
{
	if (list->size == 0)
		return;
	Node* p = find(list, key);
	if (p == NULL)
	{
		printf("要删除的数据不存.\n");
		return;
	}

	if (p == list->last)
	{
		pop_back(list);
	}
	else
	{
		Node* q = p->next;
		p->data = q->data;
		p->next = q->next;
		free(q);
		list->size--;
	}
}

重点 1.10 排序

function:单循环链表排序;
1.判断长度，为0或1均不需要进行排序;
2.断开链子，让当前只有一个节点，修改好last和first;
3.s作为需要插入的数，定义p节点循环遍历(没循环到last)直到找第一个p后继节点数据域比s数据域大的数;
4.已经到了最后还是找不到，进行尾插操作，否则插到p前面即可。

如下图：
在这里插入图片描述

void sort(List* list)
{
	if (list->size == 0 || list->size == 1)
		return;

	Node* s = list->first->next;
	Node* q = s->next;
	//断开链子
	list->last->next = NULL;
	list->last = s;
	list->last->next = list->first;

	while (q != NULL)
	{
		s = q;
		q = q->next;

		Node* p = list->first;
		while (p->next != list->last && p->next->data < s->data)
		{
			p = p->next;
		}

		if (p->next == list->last && p->next->data < s->data)
		{
			s->next = list->last->next;
			list->last->next = s;
			list->last = s;
		}
		else
		{
			s->next = p->next;
			p->next = s;
		}
	}
}

1.11 反转

function:逆序
1.判断长度0或者1不需要逆序;
2.断开链子保证只有第一个节点存在;
3.头插进去实现逆序;

void resver(List* list)
{
	if (list->size == 0 || list->size == 1)
		return;
	Node* p = list->first->next;
	Node* q = p->next;

	list->last->next = NULL;
	list->last = p;
	list->last->next = list->first;

	while (q != NULL)
	{
		p = q;
		q = q->next;

		p->next = list->first->next;
		list->first->next = p;
	}
}

1.12 清空

function:清空;
1.first后继节点赋给定义新节点，一直删除first节点下一个节点直到到last节点;
2.first和last指向以及长度更新;

void clear(List* list)
{
	Node* p = list->first->next;
	while (p != list->first)
	{
		list->first->next = p->next;
		free(p);
		p = list->first->next;
	}

	list->last = list->first;
	list->last->next = list->first;
	list->size = 0;
}

1.13 销毁

void destroy(List* list)
{
	clear(list);
	free(list->first);
	list->first = list->last = NULL;
}

二、完整代码

2.1 .h头文件

#ifndef __SCLIST_H__
#define __SCLIST_H__

#include<stdio.h>
#include<malloc.h>
#include<assert.h>

#define ElemType int

typedef struct Node
{
	ElemType data;
	struct Node *next;
}Node, *PNode;

typedef struct List
{
	PNode first;
	PNode last;
	int   size;
}List;

Node* _buynode(ElemType x);

void InitSCList(List *list);

void push_back(List *list, ElemType x);
void push_front(List *list, ElemType x);
void show_list(List *list);

void pop_back(List *list);
void pop_front(List *list);
void insert_val(List *list, ElemType x);
Node* find(List *list, ElemType key);
int  length(List *list);
void delete_val(List *list, ElemType key);
void sort(List *list);
void resver(List *list);
void clear(List *list);
void destroy(List *list);

#endif //__SCLIST_H__

2.2 .cpp源文件


#include"SCList.h"

Node* _buynode(ElemType x)
{
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	s->data = x;
	s->next = NULL;
	return s;
}

void InitSCList(List *list)
{
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	list->first = list->last = s;
	list->last->next = list->first;
	list->size = 0;
}

void push_back(List *list, ElemType x)
{
	Node *s = _buynode(x);
	list->last->next = s;
	list->last = s;
	list->last->next = list->first;
	list->size++;
}

void push_front(List *list, ElemType x)
{
	Node *s = _buynode(x);
	s->next = list->first->next;
	list->first->next = s;
	if(list->first == list->last)
	{
		list->last = s;
	}
	list->size++;
}

void show_list(List *list)
{
	Node *p = list->first->next;
	while(p != list->first)
	{
		printf("%d-->",p->data);
		p = p->next;
	}
	printf("Nul.\n");
}

void pop_back(List *list)
{
	if(list->size == 0)
		return;

	Node *p = list->first;
	while(p->next != list->last)
	{
		p = p->next;
	}

	free(list->last);
	list->last = p;
	list->last->next = list->first;
	list->size--;
}

void pop_front(List *list)
{
	if(list->size == 0)
		return;
	Node *p = list->first->next;
	list->first->next = p->next;
	free(p);
	if(list->size == 1)
	{
		list->last = list->first;
	}
	list->size--;
}

void insert_val(List *list, ElemType x)
{
	Node *p = list->first;
	while(p->next!=list->last && p->next->data < x)
	{
		p = p->next;
	}

	if(p->next == list->last && p->next->data < x)
	{
		push_back(list,x);
	}
	else
	{
		Node *s = _buynode(x);
		s->next = p->next;
		p->next = s;
		list->size++;
	}
}

Node* find(List *list, ElemType key)
{
	if(list->size == 0)
		return NULL;

	Node *p = list->first->next;
	while(p != list->first && p->data!=key)
		p = p->next;

	if(p == list->first)
		return NULL;
	return p;
}

int  length(List *list)
{
	return list->size;
}

void delete_val(List *list, ElemType key)
{
	if(list->size == 0)
		return;
	Node *p = find(list,key);
	if(p == NULL)
	{
		printf("要删除的数据不存.\n");
		return;
	}

	if(p == list->last)
	{
		pop_back(list);
	}
	else
	{
		Node *q = p->next;
		p->data = q->data;
		p->next = q->next;
		free(q);
		list->size--;
	}
}

void sort(List *list)
{
	if(list->size==0 || list->size==1)
		return;

	Node *s = list->first->next;
	Node *q = s->next;

	list->last->next = NULL;
	list->last = s;
	list->last->next = list->first;

	while(q != NULL)
	{
		s = q;
		q = q->next;

		Node *p = list->first;
		while(p->next!=list->last && p->next->data < s->data)
		{
			p = p->next;
		}
		
		if(p->next == list->last && p->next->data < s->data)
		{
			s->next = list->last->next;
			list->last->next = s;
			list->last = s;
		}
		else
		{
			s->next = p->next;
			p->next = s;
		}
	}
}

void resver(List *list)
{
	if(list->size==0 || list->size==1)
		return;
	Node *p = list->first->next;
	Node *q = p->next;

	list->last->next = NULL;
	list->last = p;                    
	list->last->next = list->first;

	while(q != NULL)
	{
		p = q;
		q = q->next;

		p->next = list->first->next;
		list->first->next = p;
	}
}

void clear(List *list)
{
	Node *p = list->first->next;
	while(p != list->first)
	{
		list->first->next = p->next;
		free(p);
		p = list->first->next;
	}

	list->last = list->first;
	list->last->next = list->first;
	list->size = 0;
}

void destroy(List *list)
{
	clear(list);
	free(list->first);
	list->first = list->last = NULL;
}

2.3 Main.cpp文件

#include"SCList.h"

int main()
{
	List mylist;
	InitSCList(&mylist);

	ElemType Item;
	Node *p = NULL;
	int select = 1;
	while(select)
	{
		printf("**************************************\n");
		printf("* [1] push_back      [2] push_front  *\n");
		printf("* [3] show_list      [4] pop_back    *\n");
		printf("* [5] pop_front      [6] insert_val  *\n");
		printf("* [7] find           [8] length      *\n");
		printf("* [9] delete_val     [10] sort       *\n");
		printf("* [11] resver        [12] clear      *\n");
		printf("* [13*] destroy       [0] quit_system*\n");
		printf("**************************************\n");
		printf("请选择:>");
		scanf("%d",&select);
		if(select == 0)
			break;
		switch(select)
		{
		case 1:
			printf("请输入要插入的数据(-1结束):>");
			while(scanf("%d",&Item),Item != -1)
			{
				push_back(&mylist,Item);
			}
			break;
		case 2:
			printf("请输入要插入的数据(-1结束):>");
			while(scanf("%d",&Item),Item != -1)
			{
				push_front(&mylist,Item);
			}
			break;
		case 3:
			show_list(&mylist);
			break;
		case 4:
			pop_back(&mylist);
			break;
		case 5:
			pop_front(&mylist);
			break;
		case 6:
			printf("请输入要插入的数据:>");
			scanf("%d",&Item);
			insert_val(&mylist,Item);
			break;
		case 7:
			printf("请输入要查找的数据:>");
			scanf("%d",&Item);
			p = find(&mylist,Item);
			if(p == NULL)
			{
				printf("要查找的数据在链表中不存在.\n");
			}
			break;
		case 8:
			printf("单链表的长度为:> %d \n",length(&mylist));
			break;
		case 9:
			printf("请输入要删除的值:>");
			scanf("%d",&Item);
			delete_val(&mylist,Item);
			break;
		case 10:
			sort(&mylist);
			break;
		case 11:
			resver(&mylist);
			break;
		case 12:
			clear(&mylist);
			break;
		//case 13:
		//	destroy(&mylist);
		//	break;
		default:
			printf("输入的命令错误,请重新输入.\n");
			break;
		}
	}
	destroy(&mylist);
	return 0;
}

爱喝冰红茶的方舟

关注

4
点赞
踩
27

收藏

觉得还不错? 一键收藏
打赏
0
评论
【数据结构|单循环链表】单循环链表大部分基本操作总结（严蔚敏数据结构）

本文基本涵盖了单循环链表的大部分基本操作，与严蔚敏数据结构内容大致贴合，且大部分函数取名结合STL，可结合来学习，可直接最后跳转完整代码复制，代码运行没问题（截图省了）有问题欢迎交流。
复制链接

扫一扫