循环链表（C语言)

于 2023-10-15 16:57:18 发布
阅读量243 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54454406/article/details/133843644
版权

1.循环链表的定义

循环双链表是对双链表的改进，将尾结点与头结点建立连接，使得尾结点可以直接查找到头结点，头结点也能够直接查找到头结点，以此来提高查找的效率。

2.循环链表的优点

  • 遍历时，可以从任何节点开始并以任何方向向前或向后遍历列表，直到到达开始的同一节点。
  • 循环链表没有开始也没有结束
  • 在循环链表中，最后一个节点地址部分保存第一个节点的地址，从而形成一个循环链状结构

3.循环链表的基本运算

初始化；创建一个循环链表，并为链表的头节点分配内存空间。
头和尾插法建立：在循环链表的尾部或指定位置插入一个新的节点，更新后继指针和头节点指针。
判空：判断循环链表是否为空。
销毁：释放循环链表的内存空间，包括头节点和各个节点的内存空间。
输出：循环输出链表中的数据
查找（按数值/位置）
插入（按数值/位置进行前/后插）
删除（按数值/位置）

1.操作步骤

1.1初始化循环链表：循环链表的初始化需要创建一个节点结构体，包含数据域和指针域。

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

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

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

运行图：1.2插入元素

此处分为两个部分，一个是头插法，一个是尾插法。

1.2.1：头插法

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

/*2. 插入元素,头插法*/
int insert_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;
}

当插入新节点时，利用头节点的指针域始终指向头节点的后继节点的特点，来对新插入的节点完成前驱后继节点的设置。这样链表内数据顺序是与输入顺序逆序的。

头插法运行图：

1.2.2尾插法

创建一个新的节点，并将其加入到循环链表的尾部。

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


/*2. 插入元素,头插法*/
int insert_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;
}

如果链表为空，则新节点既是头节点也是尾节点；否则，将其添加到尾节点的后面，并更新尾节点为新节点。同时，将新节点的 next 指针指向头节点，形成循环。

1.3：插入元素：在第i个位置插入元素。注意：我们需要首先创建一个新的节点，然后调整节点的指针以适应新的链表结构。在循环链表中，我们需要特别注意尾节点的处理。

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

/*2. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x)
{
    int j;
    SingleLinkNode *p;
    SingleLinkNode *newNode;
    if(0<i<=length+1)
    {
        printf("位置i不是链表有效位置！[100005]\n");
        return 100005;
    }
    p = (*Head);
    j = 1;

    while(j<i)
    {
        j++;
        p = p->next;
    }

    newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
    /*此处省略检测newNode是否申请成功*/

    newNode->data = x;
    newNode->next = p->next;
    p->next = newNode;
    return 0;
}

运行图：

1.4：删除指定节点：前一个节点的 next 指针指向当前节点的下一个节点，从而删除当前节点。同时，释放当前节点的内存，并结束循环。最后返回。

/*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<i)
    {
        j++;
        p = p->next;
    }

    q = p->next;
    p->next = q->next;

    free(q); /*释放内存*/

    return 0;
}

1.5：查找指定值：遍历链表中的每个节点，如果节点的数据等于目标值，就返回该节点在链表中的位置。


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

    i = 1;
    p = Head->next;

    while(p!= Head && p->data != x)  
    {
        i++;
        p = p->next;
    }

    if(p->next == Head)
    {
        return 0;
    }
    else
    {
        return i;
    }

}

运行图：1.6：求链表的长度：


/*6. 求链表的长度 */
int length(SingleLinkList *Head);
/*4. 链表长度*/
int length(SingleLinkList *Head)
{
    int len=0;
    SingleLinkNode *p;

    p = Head->next;
    while(p!=Head)	/* while(p!=Head) */
    {
        len++;
        p = p->next;
    }
    return len;
}

运行图：

1.7输出链表：接受一个循环链表的指针，然后从头节点开始遍历整个链表，并打印出每个节点的数据值。

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

/*6.输出链表*/
void print(SingleLinkList *Head)
{
    SingleLinkNode *p;
    int i=0;

    p = Head->next;
    if(p!=Head)
    {
        printf("链表为空！\n");
        return;
    }
    while(p!=Head)
    {
        printf("Node[%d]. = %d\n", ++i, p->data);
        p = p->next;
    }
}

1.8：帮助：此代码和循环链表无关

运行图：

完整的运行图：

此代码的完整代码

#include <stdio.h>
#include <string.h>
#include <malloc.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);

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


/*2. 插入元素,头插法*/
int insert_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 = *Head;

    p = (*Head);

    while(p->next)
    {
        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;
    if(0<i<=length+1)
    {
        printf("位置i不是链表有效位置！[100005]\n");
        return 100005;
    }
    p = (*Head);
    j = 1;

    while(j<i)
    {
        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<i)
    {
        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!= Head && p->data != x)
    {
        i++;
        p = p->next;
    }

    if(p->next == Head)
    {
        return 0;
    }
    else
    {
        return i;
    }

}

/*4. 链表长度*/
int length(SingleLinkList *Head)
{
    int len=0;
    SingleLinkNode *p;

    p = Head->next;
    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!=Head)
    {
        printf("链表为空！\n");
        return;
    }
    while(p!=Head)
    {
        printf("Node[%d]. = %d\n", ++i, p->data);
        p = p->next;
    }
}

int main(int argc, char* argv[])
{

    char welcome[] = "\n\
           \t_ooOoo_\n"
                     "                             o8888888o\n"
                     "                             88\" . \"88\n"
                     "                             (| -_- |)\n"
                     "                             O\\  =  /O\n"
                     "                          ____/`---'\\____\n"
                     "                        .'  \\\\|     |//  `.\n"
                     "                       /  \\\\|||  :  |||//  \\ \n"
                     "                      /  _||||| -:- |||||-  \\ \n"
                     "                      |   | \\\\\\  -  /// |   |\n"
                     "                      | \\_|  ''\\---/''  |   |\n"
                     "                      \\  .-\\__  `-`  ___/-. /\n"
                     "                    ___`. .'  /--.--\\  `. . __\n"
                     "                 .\"\" '<  `.___\\_<|>_/___.'  >'\"\".\n"
                     "                | | :  `- \\`.;`\\ _ /`;.`/ - ` : | |\n"
                     "                \\  \\ `-.   \\_ __\\ /__ _/   .-` /  /\n"
                     "         ======`-.____`-.___\\_____/___.-`____.-'======\n"
                     "                             `=---='\n\n";
    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;
}

小结：经过了几天的摸索，代码逐渐成型，感谢季老师的教学与指导，才有了这样一篇拙作，如有错误，还请各位能够谅解。

与风过山岗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

与风过山岗

您的鼓励是我莫大的荣幸

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

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

打赏作者

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

抵扣说明：

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

余额充值