目录
一.基本概念
循环链表是一种特殊的链表结构。循环单链表是单链表的另一种形式，它与普通链表不同的地方在于，其结构特点链表中最后一个结点的指针域不再是结束标记，而是指向整个链表的第一个结点，从而使链表形成一个环。这也就意味着，在循环链表中，每个节点都有前驱节点和后继节点。循环链表既可以向前遍历，也可以向后遍历。循和单链表相同，循环链表也有带头结点结构和不带头结点结构两种，带头结点的循环单链表实现插入和删除操作较为方便。
二.特点
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.运行结果
七.小结
循环链表是单链表中扩展出来的结构，所以有很多的操作是和单链表相同的，与普通链表相比，循环链表可以通过尾节点的指向来实现循环访问，这使得它具有一些独特的特性和应用场景。
1216
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
