C语言双向循环列表功能vc2022版

最新推荐文章于 2023-06-26 11:26:17 发布
最新推荐文章于 2023-06-26 11:26:17 发布
阅读量1.1k 收藏
点赞数
分类专栏： C语言双向循环链表 文章标签： c++ c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/W_YCai/article/details/123764816
版权

main函数的

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include "DoubleList.h"


int main(int argc, char *argv[])
{
    DList* L = (DNode*)malloc(sizeof(DNode));
    ElemType op;

    do{
        printf("-------双向循环链表-------\n");
        printf("\t 1.  初始化\n");
        printf("\t 2.  在头部插入元素\n");
        printf("\t 3.  在尾部插入元素\n");
        printf("\t 4.  在位置i插入元素\n");
        printf("\t 5.  查找并删除元素\n");
        printf("\t 6.  查找元素\n");
        printf("\t 7.  删除位置i元素\n");
        printf("\t 8.  输出元素\n");
        printf("\t 9.  判断链表是否为空\n");
        printf("\t 10. 求列表长度\n");
        printf("\t 11. 销毁列表\n");
        printf("\t ..........\n");
        printf("\t 0. 退出\n");
        printf("请选择:");
        scanf("%d", &op);

        if (op == 0)//退出
        {
            printf("感谢使用！\n");
        }
        else if (op == 1)//初始化
        {
            if (Init(&L))
            {
                printf("初始化成功！\n");
            }
            else
            {
                printf("初始化失败！\n");
            }
        }
        else if (op == 2)//在头部插入元素
        {
            ElemType x;
            char opp;
            do {
                printf("请输入在头部插入的元素:");
                scanf("%d", &x);
                if (InsertHead(L, x) == OK)
                {
                    printf("插入头部成功！\n");
                }
                printf("是否继续(Y/N,Y)?:");
                getchar();
                scanf("%c", &opp);

                opp = (opp == 10) ? 'y' : opp;
            } while (opp == 'y' || opp == 'Y');
        }
        else if (op == 3)//在尾部插入元素
        {
            ElemType x;
            char opp;
            do {
                printf("请输入在尾部插入的元素:");
                scanf("%d", &x);
                if (Append(L, x) == OK)
                {
                    printf("插入尾部成功！\n");
                }
                printf("是否继续(Y/N,Y)?:");
                getchar();
                scanf("%c", &opp);

                opp = (opp == 10) ? 'y' : opp;
            } while (opp == 'y' || opp == 'Y');
        }
        else if (op == 4)//在位置i插入元素
        {
            ElemType x;
            int i;
            char opp;

            do
            {
                printf("请输入插入结点的位置、x值（i,x):");
                scanf("%d,%d", &i, &x);
                /*调用*/
                if (InsertAt(L, i, x) == OK)
                {
                    printf("插入结点成功！\n");
                }
                printf("是否继续(Y/N,Y)?:");
                getchar();
                scanf("%c", &opp);

                opp = (opp == 10) ? 'y' : opp;

            } while (opp == 'y' || opp == 'Y');
        }
        else if (op == 5)//查找并删除元素
        {
            char opp;
            int x;
            do {
                printf("请输入要查找并删除的元素：");
                scanf("%d", &x);
                Delete(L, x);
                printf("是否继续(Y/N,Y)?:");
                getchar();
                scanf("%c", &opp);

                opp = (opp == 10) ? 'y' : opp;

            } while (opp == 'y' || opp == 'Y');
        }
        else if (op == 6)//查找元素
        {
            char opp;
            int x;
            do {
                printf("请输入要查找的元素：");
                scanf("%d", &x);
                Find(L, x);
                printf("是否继续(Y/N,Y)?:");
                getchar();
                scanf("%c", &opp);

                opp = (opp == 10) ? 'y' : opp;

            } while (opp == 'y' || opp == 'Y');
        }
        else if (op == 7)//删除位置i元素
        {
            char opp;
            int i;
            do {
                printf("请输入删除的位置i：");
                scanf("%d", &i);
                if (DeleteAt(L, i))
                {
                    printf("删除成功！\n");
                }
                printf("是否继续(Y/N,Y)?:");
                getchar();
                scanf("%c", &opp);

                opp = (opp == 10) ? 'y' : opp;

            } while (opp == 'y' || opp == 'Y');
        }
        else if (op == 8)//输出元素
        {
            Output(L);
        }
        else if (op == 9)//判断链表是否为空
        {
            if (ListLength(L) == 0)
            {
                printf("该列表为空！\n");
            }
            else
            {
                printf("该列表有%d个元素！\n", ListLength(L));
            }
        }
        else if (op == 10)//求列表长度
        {
            printf("该列表共有%d个元素！\n", ListLength(L));
        }
        else if (op == 11)//销毁列表
        {
            Destroy(L);
        }
        else
        {
            printf("其他功能还在待开发阶段！\n");
        }
    } while (op != 0);

    return 0;
}

DoubleList.c的

#define _CRT_SECURE_NO_WARNINGS 1

/*

  DoubleList.c

 */
#include <stdio.h>
#include <stdlib.h>

#include "DoubleList.h"

 /*双向链表初始化*/
Status Init(DList** L)
{
    DNode* head = (DNode*)malloc(sizeof(DNode));

    head->prev = head;
    head->next = head;

    *L = head;
    return OK;
}

/*插入操作，新元素放入第一个位置*/
Status InsertHead(DList* L, ElemType x)
{
    DNode* dnode = (DNode*)malloc(sizeof(DNode));

    dnode->data = x;

    dnode->prev = L;
    dnode->next = L->next;
    L->next->prev = dnode;
    L->next = dnode;
    return OK;
}


/*扩展元素，在尾部插入元素*/
Status Append(DList* L, ElemType x)
{
    DNode* newNode = (DNode*)malloc(sizeof(DNode));
    DNode* p;
    newNode->data = x;

    p = L;
    while (p->next != L)
    {
        p = p->next;
    }

    newNode->next = L;
    newNode->prev = p;
    p->next = newNode;

    return OK;
}

/*在位置i插入元素x*/
Status InsertAt(DList* L, int i, ElemType x)
{
    DNode* newNode = (DNode*)malloc(sizeof(DNode));
    DNode* p=L;
    int n;
    
    if (i<1 || i>ListLength(L)+1)
    {
        printf("越界了，该链表只有%d个元素！", ListLength(L));
        return ERROR;
    }
    for (n = 0; n < i; n++)
    {
        p = p->next;
    }
    newNode->data = x;

    newNode->prev = p->prev;
    p->prev->next = newNode;
    newNode->next = p;
    p->prev = newNode;
    return OK;
}

/*查找并删除元素x*/
Status Delete(DList* L, ElemType x)
{
    DNode* p;

    p = L;
    while (p->next != L)
    {
        p = p->next;
        if (p->data == x)
        {
            p->next->prev = p->prev;
            p->prev->next = p->next;
            free(p);
            printf("元素%d已删除！\n", x);
            return OK;
        }
    }
    printf("元素%d不存在\n", x);
    return ERROR;

}


/*删除位置i元素*/
Status DeleteAt(DList* L, int i)
{
    DNode* p=L;
    int n;
    if (ListLength(L) == 0)
    {
        printf("这个列表没有元素，请先添加元素！\n");
        return ERROR;
    }
    if(i< 1|| i>ListLength(L))
    {
        printf("没有%d这个位置！\n", i);
        return ERROR;
    }
    for (n = 0; n < i;n++)
    {
        p = p->next;
    }
    p->next->prev = p->prev;
    p->prev->next = p->next;
    free(p);
    return OK;
}

/*输出*/
void Output(DList* L)
{
    DNode* p;
    int i = 0;

    p = L;
    while (p->next != L)
    {
        i++;
        p = p->next;
        printf("Node %d. %d\n", i, p->data);
    }
}

/*查找元素*/
Status Find(DList* L, ElemType x)
{
    DNode* p;
    ElemType i=0;

    p = L;
    while (p->next != L)
    {
        p = p->next;
        i++;
        if (p->data == x)
        {
            printf("元素%d是第%d个元素\n", x,i);
            return OK;
        }
    }
    printf("元素%d不存在\n", x);
    return ERROR;
}

/*列表长度*/
Status ListLength(DList* L)
{
    DNode* p;
    ElemType n = 0;
    p = L;

    while (p->next != L)
    {
        p = p->next;
        n++;
    }
    return n;
}

 /*销毁列表*/
void Destroy(DList* L)
{
    DNode *p, *q;
    p = L->next;
    q = L;
    while (q->next != L)
    {
        q = p->next;
        free(p);
        p = q;
    }
    free(L);
    free(q);
    printf("销毁成功！\n");
}

头文件DoubleList.h的

/*

  DoubleList.h

*/

#define ERROR    0
#define OK        1
#define Overflow    2
#define Underflow    3
#define NotPresent    4
#define Duplicate    5


typedef int Status;
typedef int ElemType;


/* 双向链表结点*/
typedef struct dnode
{
    ElemType data;
    struct dnode* prev, * next;
}DNode, DList;

/*双向链表初始化*/
Status Init(DList** L);

/*插入操作，新元素放入第一个位置*/
Status InsertHead(DList* L, ElemType x);

/*扩展元素，在尾部插入元素*/
Status Append(DList* L, ElemType x);

/*在位置i插入元素x*/
Status InsertAt(DList* L, int i, ElemType x);

/*查找并删除元素x*/
Status Delete(DList* L, ElemType x);

/*删除位置i元素*/
Status DeleteAt(DList* L, int i);

/*输出*/
void Output(DList * L);

/*查找元素*/
Status Find(DList* L, ElemType x);

/*列表长度*/
Status ListLength(DList* L);

/*销毁列表*/
void Destroy(DList* L);

不知道为什么我的销毁列表有问题，必须列表有两个或两个以上的元素才能成功，否则就会断点报错，还请大神指导指导！！！

春枝秋叶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言中双向链表和双向循环链表详解
08-30
主要介绍了C语言中双向链表和双向循环链表详解的相关资料,需要的朋友可以参考下
双链表初始化、CRUD （超详细、完整代码）
m0_60284144的博客
04-17 1758
int data;//这里是指针 定义一个指针类型区域 prior就指向相同数据类型的节点双链表在单链表的基础上多加了一个prior指针，指向其前驱。因此双链表的按值查找和按位查找和单链表是相同的，但是插入和删除与单链表不同 因为插入删除还要兼顾到prior指针（要保证插入和删除后prior指针依然指向前驱）
循环双向链表的初始化及创建-头插法和尾插法
小陈没烦恼
02-03 2675
什么是循环双向链表？ 为克服单链表的这种单向性特点，在双向链表的结点有两个指针域，一个指向直接后继，另一个指向直接前驱。 循环双向链表的操作 1.初始化 2.头插法创建链表 3.尾插法创建链表 4.打印链表中的所有元素 5.可以把循环单链表和循环双向链表来对比一下来理解。参考文章：循环单链表基本操作 循环双链表的结构 这个地方要区别循环单链表，单链表中只有一个指针域，而循环双链表有两个指针域。 typedef struct DuLNode{ int data; //数...
列表基本知识和常用操作
weixin_48118301的博客
10-08 3017
列表的增删查改等常用操作。
C语言实现单链表 && 双向链表
m0_64240499的博客
08-03 642
单链表&&双向链表
c语言数据结构-循环列表
来自计科大一萌新的编程记录本
01-05 1385
c语言数据结构-循环列表
C语言数据结构之双向循环链表的实例
08-30
主要介绍了C语言数据结构之双向循环链表的实例的相关资料,需要的朋友可以参考下
双向循环链表-C语言实现.doc
最新发布
09-21
来点硬核的，莲花宝典，武林霸主
C语言实现循环链表
08-18
主要为大家详细介绍了C语言实现循环链表，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
创建列表方法
weixin_43811239的博客
03-02 3485
创建列表
C语言 单向列表操作详解
chenbofan223的博客
04-22 3752
> 学习分享，如若觉得有错误或有更好见解，欢迎评论或者私信指点<
c语言实现一个列表list
热门推荐
LearningNote
06-28 4万+
#include &quot;stdafx.h&quot; #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;malloc.h&amp;gt; struct plist {//定义列表结构体 int A[1000]; int n; }; void List_Init(plist *list); void List_Append(plist* list, int value...
C语言基础入门之C语言列表的增删改查与指针链表详解
qq_72290695的博客
06-26 3266
然后，我们插入了一个新的指针到列表的指定位置，删除了一个指针，修改了一个指针的值，并查找了一个指针的位置。在上面的示例中，我们定义了一个名为insertElement的函数，该函数用于将元素插入到指定的位置。在上面的示例中，我们定义了一个名为deleteElement的函数，该函数用于删除指定位置的元素。在上面的示例中，我们定义了一个名为findElement的函数，该函数用于查找指定元素在列表中的位置。在上面的示例中，我们定义了一个名为modifyElement的函数，该函数用于修改指定位置的元素。
C语言-数据结构-列表
卜陋专酱
03-09 6987
全军出击线性表线性表的本质线性表的操作线性表的顺序存储结构获得元素的操作插入元素的操作删除元素操作链式存储结构获取第pos个元素的操作插入操作删除操作 线性表 顺序表 链式表 线性表的本质 定义： 由0个或多个数据元素的集合 数据元素之间是有顺序的 数据元素的个数是有限个 数据元素的类型必须相同 专业的定义： 线性表是具有相同类型的n(n>=0)个数据元素的有限序列 (a0,a1,a2,..an) ai是表项，n是长度 性质： a0为线性表的第一个元素，只有一个后继 an
【c语言】循环链表（适合初学者）
weixin_74337975的博客
04-07 2133
循环链表是一种特殊的链表数据结构，与单向链表或双向链表相比，循环链表的最后一个节点的下一个节点指向第一个节点，从而形成一个环形结构。因此，循环链表可以在最后一个节点后继续添加节点，并且可以像单向链表或双向链表一样遍历、查找和删除节点。循环链表通常有一个头指针和一个尾指针，它们指向第一个节点和最后一个节点，以便在添加或删除节点时快速定位。循环链表可以用于解决某些问题，例如模拟一个环形队列，或者用于实现循环播放的音乐列表等。
C语言——详解带头双向循环链表 增删查改
qq_62476499的博客
01-08 725
详细讲解带头循环双向链表的增删查改等基本操作
带头双向循环链表增删查改实现（c语言）
m0_69023444的博客
08-29 342
当我们在写单链表时，常常因为它不能通过一个节点访问前一个节点而烦恼，今天，我就来给大家介绍介绍它的超级无敌plus版本-------带头双向循环链表（自带音响。完成一个链表就需要有一些它的基本功能，所以接下来，我将尽可能地向大家讲解它的增删查改，那么话不多说，我们开始吧！因为在后面会多次创建新的节点，所以我把它分装成了一个函数，并将其放在前面。因为是晚上写的，可能会有部分错误，欢迎大家斧正。（2）尾插（对于双向链表而言，尾插某种意义上也是头插）编译器：vs2022。人类的力量是有限的，所以，我不做人啦！..
循环结构、双重循环
程序豆的博客
03-09 1831
循环结构、双重循环
列表的定义与基本使用！！ 全部都是干货！！！！
LiuShuLi_的博客
05-08 5471
为了大家能够更直观的了解列表，这里放了一张图，供大家参考！ 一、定义与基本使用 接下来就是案例啦 ！准备好了吗？？？ 1、列表的定义 2、获取列表中的值 3、获取索引（下标） 4、修改列表中的值 5、append 添加 6、 insert 添加 insert（索引，需要插入的值 7、extend扩展， A.extend(B),将B列表中元素放到A的后面 8、 remove:删除列表中具体的值 9、 pop() 把结尾元素删除 10、 pop(2) 指定 索引的删除 11、长度 的长度
c语言双向循环链表例题
09-05
以下是一个C语言的双向循环链表的例题： ```c #include #include struct Node { int data; struct Node* next; struct Node* prev; }; void insert(struct Node** head, int data) { struct Node* newNode ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值