循环链表详解

sdrsdsaf

已于 2023-10-15 19:08:16 修改

阅读量879

点赞数

文章标签：链表数据结构

于 2023-10-15 19:06:36 首次发布

本文链接：https://blog.csdn.net/Q2076530986/article/details/133844927

版权

一.基本概念

循环链表是一种特殊的链表结构。循环单链表是单链表的另一种形式，它与普通链表不同的地方在于，其结构特点链表中最后一个结点的指针域不再是结束标记，而是指向整个链表的第一个结点，从而使链表形成一个环。这也就意味着，在循环链表中，每个节点都有前驱节点和后继节点。循环链表既可以向前遍历，也可以向后遍历。循和单链表相同，循环链表也有带头结点结构和不带头结点结构两种，带头结点的循环单链表实现插入和删除操作较为方便。

二.特点

1.循环链表的节点由数据域和指针域组成，其中指针域指向下一个节点。

2.循环链表的尾节点的指针域指向头节点，形成一个闭环。

3.循环链表可以从任意节点开始遍历，通过尾节点的指针域可以实现循环访问。

4.循环链表的插入和删除操作相对于普通链表更加简便。

三.基本运算

1.初始化

*1.初始化*/
int init(SingleLinkList** Head) {
	if (Head != NULL) {
		/*申请内存*/
		(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
		/*判断内存申请是否成功*/
		if (*Head == NULL) {
			printf("申请内存错误，初始化失败！[100001]\n");
			return 100001;
		}
		//(*Head)->next = NULL;
		/*循环链表*/
		/*
		(*Head)->next = Head;
		*/
		(*Head)->next = *Head;
		return 0;
	}
	else {
		printf("该链表已经初始化！请删除后在执行此操作！[100002]\n");
		return 100002;
	}
}

2.插入元素

头插法:

/*2.插入元素，头插法*/
int sert_head(SingleLinkList** Head, DataType x) {
	SingleLinkNode* newNode;
	if (0) {
		printf("链表未初始化![100003]\n");
		return 100003;
	}
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	if (!newNode) {
		printf("申请节点内存空间失败![100004]\n");
		return 100004;
	}
	newNode->data = x;
	newNode->next = (*Head)->next;

	(*Head)->next = newNode;
	return 0;
}

尾插法:

/*2.插入元素，尾插法*/
int insert_tail(SingleLinkList** Head, DataType x) {
	SingleLinkNode* newNode;
	SingleLinkNode* p;
	if (0) {
		printf("链表未初始化成功![100003]\n");
		return 100003;
	}
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	if (!newNode) {
		printf("申请节点内存空间失败![100004]\n");
		return 100004;
	}
	newNode->data = x;
	//newNode -> next = NULL;
	/*循环列表*/
	/* newNode->newxt=Head;
	*/
	newNode->next = Head;
	p = *Head;
	while (p->next != NULL && p->next != *Head) {
		p = p->next;
	}
	p->next = newNode;
	return 0;
}

在位置i处插入元素x:

/*2.插入元素，在位置i出插入元素x*/
int insert(SingleLinkList** Head, int i, DataType x) {
	int j;
	SingleLinkNode* p;
	SingleLinkNode* newNode;
	/*对i进行判断，0<i<=length+1*/
	if (i<1 || i>length(*Head) + 1) {
		printf("位置i不是链表的有效位置![100005]\n");
		return 100005;
	}
	p = (*Head);
	j = 1;
	while (j < 1) {
		j++;
		p = p->next;
	}
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	/*此处省略检测newNode是否申请成功*/
	newNode->data = x;
	newNode->next = p->next;
	p->next = newNode;
	return 0;
}

3.删除元素

/*3.删除元素，删除值为x的元素*/
int delete(SingleLinkList** Head, DataType x) {
	int i;
	int j;
	SingleLinkNode* p;
	SingleLinkNode* q;/*要删除的元素x*/
	i = find(*Head, x);
	if (!i) {
		printf("元素x【%d】不存在! 100006\n", x);
		return 100006;
	}
	p = (*Head);
	j = 1;
	while (j < 1) {
		j++;
		p = p->next;
	}
	q = p->next;
	p->next = q->next;
	free(q);/*释放内存*/
	return 0;
}

4.链表长度

/*4.链表长度*/
int length(SingleLinkList* Head) {
	int len = 0;
	SingleLinkNode* p;
	p = Head->next;
	//while(p)/*while(p!=Head)*/
	while (p != Head) {
		len++;
		p = p->next;
	}
	return len;
}

5.查找元素

/*5.查找值为x的元素，返回位置i*/
int find(SingleLinkList* Head, DataType x) {
	int i;
	SingleLinkNode* p;
	i = 1;
	p = Head->next;
	while (p && p->data != x)/*while(p != Head && p->data != x)*/ {
		i++;
		p = p->next;
	}
	if (!p)/*if(p -> next == Head)*/ {
		return 0;
	}
	else {
		return i;
	}
}

6.输出链表

/*6.输出链表*/
void print(SingleLinkList* Head) {
	SingleLinkNode* p;
	int i = 0;
	p = Head->next;
	if (!p)/*if(p!=Head)*/ {
		printf("链表为空!\n");
		return;
	}
	//while(p!=Head)
	//{
	//   p = p -> next;
	//}
	//while(p) /*while(p!=Head)*/
	while (p != Head) {
		printf("Node[%d].=%d\n", ++i, p->data);
		p = p->next;
	}
}

四.完整的DEMO

SingleLinkList.h

typedef int DataType;

/*简单链表的定义*/
typedef struct node
{
	DataType		data;	/*数据域*/
	struct node* next;	/*指针域*/
}SingleLinkList, SingleLinkNode;


/*1. 初始化*/
int init(SingleLinkList** Head);

/*2. 插入元素,头插法*/
int insert_head(SingleLinkList** Head, DataType x);

/*2. 插入元素， 尾插法*/
int insert_tail(SingleLinkList** Head, DataType x);

/*2. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList** Head, int i, DataType x);

/*3. 删除元素, 删除值为x的元素*/
int delete(SingleLinkList** Head, DataType x);

/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList* Head, DataType x);

/*6. 求链表的长度 */
int length(SingleLinkList* Head);

/*7.输出链表*/
void print(SingleLinkList * Head);

SingleLinkList.c

#include "SingleLinkList.h"
#include <stdio.h>
#include <stdlib.h>
/*1.初始化*/
int init(SingleLinkList** Head) {
	if (Head != NULL) {
		/*申请内存*/
		(*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
		/*判断内存申请是否成功*/
		if (*Head == NULL) {
			printf("申请内存错误，初始化失败！[100001]\n");
			return 100001;
		}
		//(*Head)->next = NULL;
		/*循环链表*/
		/*
		(*Head)->next = Head;
		*/
		(*Head)->next = *Head;
		return 0;
	}
	else {
		printf("该链表已经初始化！请删除后在执行此操作！[100002]\n");
		return 100002;
	}
}
/*2.插入元素，头插法*/
int sert_head(SingleLinkList** Head, DataType x) {
	SingleLinkNode* newNode;
	if (0) {
		printf("链表未初始化![100003]\n");
		return 100003;
	}
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	if (!newNode) {
		printf("申请节点内存空间失败![100004]\n");
		return 100004;
	}
	newNode->data = x;
	newNode->next = (*Head)->next;

	(*Head)->next = newNode;
	return 0;
}
/*2.插入元素，尾插法*/
int insert_tail(SingleLinkList** Head, DataType x) {
	SingleLinkNode* newNode;
	SingleLinkNode* p;
	if (0) {
		printf("链表未初始化成功![100003]\n");
		return 100003;
	}
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	if (!newNode) {
		printf("申请节点内存空间失败![100004]\n");
		return 100004;
	}
	newNode->data = x;
	//newNode -> next = NULL;
	/*循环列表*/
	/* newNode->newxt=Head;
	*/
	newNode->next = Head;
	p = *Head;
	while (p->next != NULL && p->next != *Head) {
		p = p->next;
	}
	p->next = newNode;
	return 0;
}
/*2.插入元素，在位置i出插入元素x*/
int insert(SingleLinkList** Head, int i, DataType x) {
	int j;
	SingleLinkNode* p;
	SingleLinkNode* newNode;
	/*对i进行判断，0<i<=length+1*/
	if (i<1 || i>length(*Head) + 1) {
		printf("位置i不是链表的有效位置![100005]\n");
		return 100005;
	}
	p = (*Head);
	j = 1;
	while (j < 1) {
		j++;
		p = p->next;
	}
	newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
	/*此处省略检测newNode是否申请成功*/
	newNode->data = x;
	newNode->next = p->next;
	p->next = newNode;
	return 0;
}
/*3.删除元素，删除值为x的元素*/
int delete(SingleLinkList** Head, DataType x) {
	int i;
	int j;
	SingleLinkNode* p;
	SingleLinkNode* q;/*要删除的元素x*/
	i = find(*Head, x);
	if (!i) {
		printf("元素x【%d】不存在! 100006\n", x);
		return 100006;
	}
	p = (*Head);
	j = 1;
	while (j < 1) {
		j++;
		p = p->next;
	}
	q = p->next;
	p->next = q->next;
	free(q);/*释放内存*/
	return 0;
}
/*5.查找值为x的元素，返回位置i*/
int find(SingleLinkList* Head, DataType x) {
	int i;
	SingleLinkNode* p;
	i = 1;
	p = Head->next;
	while (p && p->data != x)/*while(p != Head && p->data != x)*/ {
		i++;
		p = p->next;
	}
	if (!p)/*if(p -> next == Head)*/ {
		return 0;
	}
	else {
		return i;
	}
}
/*4.链表长度*/
int length(SingleLinkList* Head) {
	int len = 0;
	SingleLinkNode* p;
	p = Head->next;
	//while(p)/*while(p!=Head)*/
	while (p != Head) {
		len++;
		p = p->next;
	}
	return len;
}
/*6.输出链表*/
void print(SingleLinkList* Head) {
	SingleLinkNode* p;
	int i = 0;
	p = Head->next;
	if (!p)/*if(p!=Head)*/ {
		printf("链表为空!\n");
		return;
	}
	//while(p!=Head)
	//{
	//   p = p -> next;
	//}
	//while(p) /*while(p!=Head)*/
	while (p != Head) {
		printf("Node[%d].=%d\n", ++i, p->data);
		p = p->next;
	}
}

main.c

#include <stdio.h>
#include <string.h>
#include "SingleLinkList.c"
#include "welcome.h"
int main(int argc, char* argv[])
{
	SingleLinkList* Head;
	DataType x;
	int i, m, n, cmd;

	for (i = 0; i < strlen(welcome); i++)
	{
		printf("%c", welcome[i]);
		for (m = 0; m < 1000; m++)
			for (n = 0; n < 1000; n++)
			{
				;
			}
	}

	printf("-----------简单链表演示程序----------\n");
	do
	{
		printf("1. 初始化链表表\n");
		printf("2. 插入元素（头插法）\n");
		printf("3. 插入元素（尾插法）\n");
		printf("4. 插入元素（在位置i插入）\n");
		printf("5. 查找元素x\n");
		printf("6. 求链表长度\n");
		printf("7. 输出链表\n");
		printf("8. 删除元素\n");
		printf("10. 帮助\n");
		printf("0. 退出\n");
		printf("请输入您要进行的操作（1~6,0退出）：");
		scanf("%d", &cmd);
		switch (cmd)
		{
		case 1:
			if (!init(&Head))
			{
				printf("链表已初始化！\n");
			}
			break;
		case 2:
			printf("请输入插入元素x：x=");
			scanf("%d", &x);
			if (!insert_head(&Head, x))
			{
				printf("元素（%d）已插入\n", x);
			}
			break;
		case 3:
			printf("请输入插入元素x：x=");
			scanf("%d", &x);
			if (!insert_tail(&Head, x))
			{
				printf("元素（%d）已插入\n", x);
			}
			break;
		case 4:
			printf("请输入插入元素位置i和元素x（i，x）：");
			scanf("%d,%d", &i, &x);
			if (!insert(&Head, i, x))
			{
				printf("已在位置（%d）插入元素（%d）！\n", i, x);
			}
			break;
		case 5:
			printf("请输入要查找的元素x：");
			scanf("%d", &x);
			if (i = find(Head, x))
			{
				printf("元素%d存在，在链表位置%d.\n", x, i);
			}
			else
			{
				printf("在链表中未找到元素x。\n");
			}
			break;
		case 6:
			printf("链表的长度为：%d\n", length(Head));
			break;
		case 7:
			print(Head);
			break;
		case 8:
			printf("请输入要删除的元素x：");
			scanf("%d", &x);
			if (!delete(&Head, x))
			{
				printf("元素x【%d】已删除!\n", x);
			}
			break;
		case 10:
			printf(" 本程序为链表的演示程序，由谯琦设计开发，程序完成了循环列表的基本功能!\n");
			break;

		}
	} while (cmd != 0);

	return 0;
}

welcome.h

char welcome[] = "o(´^｀)oo(´^｀)oo(´^｀)o";

五.运行结果

1.初始化

2.插入元素

头插法：

尾插法

在位置i插入

3.查找元素

4.链表长度

5.输出链表

6.删除元素

六.拓展练习-一元多项式

1.DEMO

#include <stdio.h> 
#include<stdlib.h>
typedef struct node//一元多项式定义
{
    float coef;       // 系数
    int expn;         // 指数
    struct node* next; // 后继
} pnode, * polynomial; // 一元多项式的创建
polynomial createpolyn(polynomial p, int m)
{
    int i;
    polynomial q, pre, s;                  // 节点 q，pre，s
    p = (polynomial)malloc(sizeof(pnode)); // 生成新节点
    p->next = 0;                           // 先建立一个头节点的单链表
    p->expn = -1;                          // 头节点指数值设为-1
    for (i = 0; i < m; i++)                // 依次输入m个非零值
    {
        s = (polynomial)malloc(sizeof(pnode)); // 生成新节点
        printf("输入系数和指数：");
        scanf("%f%d", &s->coef, &s->expn); // 输入系数和指数

        pre = p;   // pre来保存q的前驱

        q = p->next; // q初值为首节点

        while (q && q->expn <= s->expn)    // 找到第一个大于输入项指数的项q
        {
            pre = q;
            q = q->next;
        }
        s->next = q; pre->next = s; // 将输入项s，插入到q和pre之间

    }
    printf("--创建成功--\n");

    return p;
}// 一元多项式打印

void pri(polynomial p)
{
    polynomial q;
    int id = 1;
    q = p->next; // 第一项（首结点）
    printf("加法运算后结果为:\n");
    while (q)
    {
        printf("第%d个结点：系数%f,指数%d\n", id, q->coef, q->expn); // 结点后移
        q = q->next;
        id++;
    } // 一元多项式相加

}

polynomial addpolyn(polynomial pa, polynomial pb)
{
    polynomial p1, p2, p3, q;
    int sum; // 系数和   sum
    p1 = pa->next; p2 = pb->next;

    p3 = pa;         // p3 指向和多项式的当前结点
    while (p1 && p2) // p1和p2均非空
    {
        if (p1->expn == p2->expn) // 指数相同
        {
            sum = p1->coef + p2->coef; // sum 保存两项的系数和
            if (sum)                   // 系数和不为0
            {
                p1->coef = sum; // 修改结点p1的系数值
                p3->next = p1;
                p3 = p1;       // 将修改后的结点p1链在p3之后
                p1 = p1->next; // p1 指向后一项
                q = p2;
                p2 = p2->next; free(q); // 删除pb当前结点q
            }
            else // 系数和为0
            {
                q = p1;
                p1 = p1->next; free(q); // 删除pa当前结点pl
                q = p2;
                p2 = p2->next;
                free(q); // 删除pb当前结点p2
            }
        }
        else
        {
            if (p1->expn <= p2->expn) // pa当前结点p1的指数值小
            {
                p3->next = p1; // 将p1链在p3之后
                p3 = p1;       // p3 指向pl
                p1 = p1->next; // p1 指向后一场
            }
            else
            {
                p3->next = p2; // pb当前结点p2的指数值小
                p3 = p2;       // 将p2链接在p3之后
                p2 = p2->next; // p2指向后一项
            }
        }
    }

    p3->next = p1 ? p1 : p2; // 插入非空多项式的剩余段
    free(pb);  // 释放pb的头结点

    return pa;               // 返回和多项式
}

main()
{
    printf("==================一元多项式演示程序==================\n\n\n");
    int m;
    polynomial pa, pb, pc; // 声明一元多项式
    printf("==================创建一元多项式==================\n");
    printf("创建 A 项数:\n");
    scanf("%d", &m);         // 创建pa项数
    pa = createpolyn(pa, m); // 创建一元多项式pa
    printf("创建 B 项数:\n");
    scanf("%d", &m);         // 创建pb项数
    pb = createpolyn(pb, m); // 创建一元多项式pb
    printf("==================一元多项式相加==================\n");

    pc = addpolyn(pa, pb); // 一元多项式相加
    pri(pc);               // 打印一元多项式
    printf("=======================END=======================\n");
    system("pause");
}

2.运行结果

七.小结

循环链表是单链表中扩展出来的结构，所以有很多的操作是和单链表相同的，与普通链表相比，循环链表可以通过尾节点的指向来实现循环访问，这使得它具有一些独特的特性和应用场景。

sdrsdsaf

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
1
评论
循环链表详解

循环链表是一种特殊的链表结构。循环单链表是单链表的另一种形式，它与普通链表不同的地方在于，其结构特点链表中最后一个结点的指针域不再是结束标记，而是指向整个链表的第一个结点，从而使链表形成一个环。这也就意味着，在循环链表中，每个节点都有前驱节点和后继节点。循环链表既可以向前遍历，也可以向后遍历。循和单链表相同，循环链表也有带头结点结构和不带头结点结构两种，带头结点的循环单链表实现插入和删除操作较为方便。
复制链接

扫一扫