c语言数据结构 -单向循环链表

最新推荐文章于 2023-06-12 11:18:26 发布
最新推荐文章于 2023-06-12 11:18:26 发布
阅读量538 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengxuewei123/article/details/115446568
版权

在这里插入图片描述

#include "CircylarLinkedlists.h"

typedef struct PERSON
{
    CircylarLinkNode node;
    char name[64];
    int age;
    int score;
}Person;

void MyPrint(CircylarLinkNode*);
int MyCompare(CircylarLinkNode*, CircylarLinkNode*);

void test01();
void test02();
void test03();


int main(int argc, char **argv){
    
    test03();
    
    return 0;
}

void test01(){
    
    CircylarLinkList* clist = Init_CircylarLinkList();

    Person p1, p2, p3, p4, p5;
    strcpy(p1.name, "aaa");
    strcpy(p2.name, "bbb");
    strcpy(p3.name, "ccc");
    strcpy(p4.name, "ddd");
    strcpy(p5.name, "eee");

    p1.age = 10;
    p2.age = 20;
    p3.age = 30;
    p4.age = 40;
    p5.age = 50;

    p1.score = 50;
    p2.score = 60;
    p3.score = 70;
    p4.score = 80;
    p5.score = 90;

    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p1);
    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p2);
    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p3);
    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p4);
    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p5);


    Print_CircylarLinkList(clist, MyPrint);

    FreeSpace_CircylarLinkList(clist);
}   



void test02(){
    
    CircylarLinkList* clist = Init_CircylarLinkList();

    Person p1, p2, p3, p4, p5;
    strcpy(p1.name, "aaa");
    strcpy(p2.name, "bbb");
    strcpy(p3.name, "ccc");
    strcpy(p4.name, "ddd");
    strcpy(p5.name, "eee");

    p1.age = 10;
    p2.age = 20;
    p3.age = 30;
    p4.age = 40;
    p5.age = 50;

    p1.score = 50;
    p2.score = 60;
    p3.score = 70;
    p4.score = 80;
    p5.score = 90;

    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p1);
    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p2);
    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p3);
    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p4);
    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p5);


    Print_CircylarLinkList(clist, MyPrint);

    Person pDel;
    strcpy(pDel.name, "ccc");
    pDel.age = 30;
    pDel.score = 70;

    RemoveByVal_CircylarLinkList(clist, (CircylarLinkNode*)&pDel, MyCompare);


    Print_CircylarLinkList(clist, MyPrint);

    FreeSpace_CircylarLinkList(clist);
}   
void test03(){
    
    CircylarLinkList* clist = Init_CircylarLinkList();

    Person p1, p2, p3, p4, p5;
    strcpy(p1.name, "aaa");
    strcpy(p2.name, "bbb");
    strcpy(p3.name, "ccc");
    strcpy(p4.name, "ddd");
    strcpy(p5.name, "eee");

    p1.age = 10;
    p2.age = 20;
    p3.age = 30;
    p4.age = 40;
    p5.age = 50;

    p1.score = 50;
    p2.score = 60;
    p3.score = 70;
    p4.score = 80;
    p5.score = 90;

    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p1);
    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p2);
    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p3);
    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p4);
    Insert_CircylarLinkList(clist, 100, (CircylarLinkNode*)&p5);


    Print_CircylarLinkList(clist, MyPrint);

    RemoveByPos_CircylarLinkList(clist, 2);


    Print_CircylarLinkList(clist, MyPrint);

    FreeSpace_CircylarLinkList(clist);
}   


void MyPrint(CircylarLinkNode* data){
    Person* p = (Person*) data;

    printf("name: %s \t age: %d \t score: %d\n", p->name, p->age, p->score);
}
int MyCompare(CircylarLinkNode* node1, CircylarLinkNode* node2){

    Person* p1 = (Person*) node1;
    Person* p2 = (Person*) node2;

    if(strcmp(p1->name, p2->name) == 0 && p1->age == p2->age && p1->score == p2->score){
        return CIRCYLARTLINKLIST_TRUE;
    }

    return CIRCYLARTLINKLIST_FALSE;
}

#include "CircylarLinkedlists.h"


// 1. 初始化函数
CircylarLinkList* Init_CircylarLinkList(){

    CircylarLinkList* clist = (CircylarLinkList*)malloc(sizeof(CircylarLinkList));

    clist->head.next = &(clist->head); 
    clist->size = 0;

    return clist;
}

// 2. 插入函数(插入位置，插入的数据)
void Insert_CircylarLinkList(CircylarLinkList* clist, int pos, CircylarLinkNode* data){
    if(clist == NULL){
        return;
    }
    if(data == NULL){
        return;
    }
    if(pos < 0 || pos > clist->size){
        pos = clist->size;
    }

    // 查找前一个节点
    CircylarLinkNode* pCurrent = &(clist->head); 
    for(int i = 0; i < pos; i++){
        pCurrent = pCurrent->next; 
    }

    // 入链表
    data->next = pCurrent->next;
    pCurrent->next = data;

    clist->size++;
}

// 3. 获得第一个元素
CircylarLinkNode* Front_CircylarLinkList(CircylarLinkList* clist){
    return clist->head.next;
}

// 4. 根据位置删除
void RemoveByPos_CircylarLinkList(CircylarLinkList* clist, int pos){
    if(clist == NULL){
        return;
    }
    if(pos < 0 || pos >= clist->size){
        return;
    }

    // 查找前一个节点
    CircylarLinkNode* pCurrent = &(clist->head); 
    for(int i = 0; i < pos; i++){
        pCurrent = pCurrent->next; 
    }

    // 删除操作，这里不需要 free 操作，因为这个 CircylarLinkNode 并不是我们通过手动来分配内存的.
    pCurrent->next = pCurrent->next->next;

    clist->size--;
}

// 5. 根据元素值来删除
void RemoveByVal_CircylarLinkList(CircylarLinkList* clist, CircylarLinkNode* data, COMPARENODE compare){
    if(clist == NULL){
        return;
    }
    if(data == NULL){
        return;
    }

    CircylarLinkNode* pPrevious = &(clist->head);
    CircylarLinkNode* pCurrent = clist->head.next;
    // while(pCurrent != NULL){
    //     if(compare(pCurrent, data) == 0){
            
    //     }
    //     // next 节点
    //     pCurrent = pCurrent->next;
    // }
    for (int i = 0; i < clist->size; i++){
        if (compare(pCurrent, data) == CIRCYLARTLINKLIST_TRUE)
        {
            // 删除
            pPrevious->next = pCurrent->next;

            clist->size--;
         
            break;
        }
        pPrevious = pCurrent;
        pCurrent = pPrevious->next;
    }
}

// 6. 获得链表的长度
int Size_CircylarLinkList(CircylarLinkList* clist){
    return clist->size;
}

// 7. 查找元素
int Find_CircylarLinkList(CircylarLinkList* clist, CircylarLinkNode* data, COMPARENODE compare){
    if(clist == NULL){
        return -1;
    }
    if(data == NULL){
        return -1;
    }

    CircylarLinkNode* pCurrent = clist->head.next;
    int i = 0;
    int flag = -1;
    for (; i < clist->size; i++)
    {
        if(compare(pCurrent,data) == 0){
            flag = i;
            break;
        }
        pCurrent = pCurrent->next;
    }
    
    return flag;
}

// 8. 打印链表
void Print_CircylarLinkList(CircylarLinkList* clist, PRINTNODE print){
    if(clist == NULL){
        return;
    }

    CircylarLinkNode* pCurrent = clist->head.next;
    for(int i = 0; i < clist->size; i++){ //
        print(pCurrent);
        pCurrent = pCurrent->next;
    }
    printf("---------------------------------\n");
    
    // 打印多遍
    // for(int i = 0; i < clist->size * 3; i++){ 
    //     if(pCurrent == &(clist->head)){
    //         pCurrent = pCurrent->next;
    //         printf("---------------------------------\n");
    //     }
    //     print(pCurrent);
    //     pCurrent = pCurrent->next;
    // }
}

// 9. 释放内存
void FreeSpace_CircylarLinkList(CircylarLinkList* clist){
    if(clist == NULL){
        return;
    }

    free(clist);
}

// 10. 判断是否为空
int IsEmpty_CircylarLinkList(CircylarLinkList* clist){
    if(clist->size == 0){
        return CIRCYLARTLINKLIST_TRUE;
    }
    return CIRCYLARTLINKLIST_FALSE;
}


#ifndef CIRCYLAR_LINKED_LISTS_SINGLE_H
#define CIRCYLAR_LINKED_LISTS_SINGLE_H


#include "stdio.h"
#include "stdlib.h"
#include "string.h"

/**
 * 单向循环链表：每个节点都有一个数据域和一个指针域，这个和单向链表是一致的。但是
 * 不一样的地方是，单向循环链表的最后一个节点的指针域不为NULL，它指向头节点也可以
 * 指向第一个有效的数据节点。这些都是单向循环链表，我们一般让其指向头结点
 * 
 * 在初始化的时候，应该将头结点的next域指向自己
 * 
 * 判断链表末尾的方式：
 * 1. 节点 next 是否等于 头结点 ==> 表示该链表结束
 * 2. 通过维护 size() 来判断是否 是该链表结束标志
 */

// 链表的挂钩
typedef struct CIRCYLARLINKNODE{
    struct CIRCYLARLINKNODE* next;
}CircylarLinkNode;


// 链表的结构体：保存的就是关于该链表的一些详细信息
typedef struct CIRCYLARLINKLIST{
    CircylarLinkNode head;
    int size;
}CircylarLinkList;

#define CIRCYLARTLINKLIST_TRUE  1
#define CIRCYLARTLINKLIST_FALSE 0

// 当两个元素相同的话，返回0；否则返回-1
typedef int(*COMPARENODE)(CircylarLinkNode*, CircylarLinkNode*); // 比较的回调函数

typedef void(*PRINTNODE)(CircylarLinkNode*);

// APIs

// 1. 初始化函数
CircylarLinkList* Init_CircylarLinkList();

// 2. 插入函数(插入位置，插入的数据)
void Insert_CircylarLinkList(CircylarLinkList* clist, int pos, CircylarLinkNode* data);

// 3. 获得第一个元素
CircylarLinkNode* Front_CircylarLinkList(CircylarLinkList* clist);

// 4. 根据位置删除
void RemoveByPos_CircylarLinkList(CircylarLinkList* clist, int pos);

// 5. 根据元素值来删除
void RemoveByVal_CircylarLinkList(CircylarLinkList* clist, CircylarLinkNode* data, COMPARENODE compare);

// 6. 获得链表的长度
int Size_CircylarLinkList(CircylarLinkList* clist);

// 7. 查找元素
int Find_CircylarLinkList(CircylarLinkList* clist, CircylarLinkNode* data, COMPARENODE compare);

// 8. 打印链表
void Print_CircylarLinkList(CircylarLinkList* clist, PRINTNODE print);

// 9. 释放内存
void FreeSpace_CircylarLinkList(CircylarLinkList* clist);

// 10. 判断是否为空
int IsEmpty_CircylarLinkList(CircylarLinkList* clist);

#endif


# commands.txt
gcc -fPIC -shared CircylarLinkedlists.c -o libcircylarLinkedlists.so
gcc main.c -o main -L ./ -lcircylarLinkedlists -Wl,-rpath ./
fengxuewei123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-链表的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 链表的部分实现代码（单向链表、双向链表、循环链表、约瑟夫环等），详细介绍参考数据结构--链表的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
C语言实现单向循环链表
知识改变命运！
10-08 832
C语言实现单向循环链表
使用C语言实现循环单链表（带头节点）
Keep_Trying_Go的博客
08-07 1615
使用C语言实现循环单链表
C语言数据结构———单项循环链表
RaphaelCeo的博客
03-21 1282
单项循环链表
C语言数据结构——循环链表
m0_73676323的博客
06-12 1546
在双向循环链表中，每个结点包括三个域，分别是 data 域、next 域和 prev 域，其中data域为数据域，next 域为指向后继结点的指针域，prev域为指向前驱结点的指针域。下图为链表的结点结构。
数据结构之循环单链表（C语言附完整代码）
m0_62795460的博客
11-09 6610
循环单链表是单链表的另一种形式，其结构特点链表中最后一个结点的指针域不再是结束标记，而是指向整个链表的第一个结点，从而使链表形成一个环。示意图：声明循环单链表typedef struct LNode //定义单链表结点类型 {注意：本文章讨论的循环单链表是带头结点的循环单链表。增加头结点的优点如下：1.循环单链表中首结点的插入和删除操作与其他结点一致，无需进行特殊处理。2.无论循环单链表是否为空都有一个头结点，因此统一了空表和非空表的处理过程。
用单向循环链表模拟约瑟夫环
04-16
用C语言编写的约瑟夫环问题解决程序，利用单向循环链表存储结构模拟此过程
第11章 动态数据结构-链表-21
08-03
在本章中，我们探讨了如何使用C语言实现动态数据结构——单向链表。单向链表是一种线性数据结构，其中每个节点包含数据以及指向下一个节点的指针。以下是一些关于单向链表的关键知识点： 1. **节点定义**：在C语言...
C语言中双向链表和双向循环链表详解
12-26
双向链表和双向循环链表 和单向链表相比，多了一个前驱结点。如果他为空，那么next和prior都指向自己。而对于双循环链表，只需要最后一个元素的next指向head->next，head->next的prior指向最后一个节点即可。 插入...
数据结构--数组、单链表和双链表介绍以及双向链表 数组和链表.pdf
04-18
数据结构--数组、单链表和双链表介绍以及双向链表 数据结构是计算机科学中的一种基本概念，指的是数据的组织和存储方式。数组、链表是两种常见的数据结构，下面将对它们进行介绍。 一、数组 数组是数据结构中的一...
数据结构——循环单链表【c语言版】
clear-ninghongkang的博客
11-19 2824
循环链表包括循环单链表和循环双链表 循环单链表的结点类型与非循环单链表相同，把非循环单链表改成循环单链表只需要将非循环单链表的尾结点next指针由原来的NULL改为指向头节点，自此就将非循环单链表形成看一个环，从表中的任一结点出发均可找到链表中其他的结点，这就是带头节点的循环单链表。 循环单链表的操作与单链表基本一致，差别在于遍历链表时，判别当前指针p是否指向表尾结点的终止条件不同： 单链表：p->next != NULL 循环单链表：p->next !=...
C语言线性表--单链表
qq_35732321的博客
06-01 155
main.c SingleLinkList.h 3 SingleLinkList.c
【数据结构-C语言】单向链表，循环单向链表
sakura0908的博客
03-02 2334
顺序表：顺序存储的线性表 链式表：链式存储的线性表，简称链表 由于顺序表的缺点（数据连续存储），顺序存储的数据因为挤在一起而导致需要成片移动，那很容易想到的解决方案是将数据离散地存储在不同内存块中，然后再用指针将他们串起来，这种朴素的思路所形成的链式线性表，就是所谓的链表。顺序表和链表存在的基本样态如下图所示
【C语言】单向循环链表（实例详解约瑟夫问题）
m0_60511809的博客
11-27 3987
类似单链表，循环链表也是一种链式的存储结构，由单链表演化而来。 单向循环链表来源于单链表，所以单链表的基本操作基本都适合于循环链表。两者的不同点主要表现在链表的建立和链表表尾的判断。 接下来我们通过分析一个经典的问题即 “ 约瑟夫问题 ”来理解单循环链表。 “ 约瑟夫问题 ” 简单来说就是：有n个人围成一个圈，规定一个数字num，从某个人开始报数，每次从1报到这个数字num，报到num的人出列，现在要我们按顺序输出...
C语言：数据结构-单向循环链表
JCapezy的博客
02-24 271
C语言：数据结构-循环单链表
循环单链表的简单实现（C语言）
文溪山人的博客
03-21 3823
循环单链表的简单实现（C语言）
掌握C语言链表
09-27
链表是一种使用极其广泛的数据结构，它也可以用来作为实现栈、队列等数据结构的基础，链表没有像数组需要预先知道数据大小的缺点，可充分利用计算机内存，实现动态灵活的内存管理。除非需要频繁的通过下标来随机访问各个数据，否则数组都可以用链表代替。链表作为C语言数据结构的难点，更是面试中必考的知识点。
C语言单链表的建立
qq_52140453的博客
08-25 556
C语言单链表的建立
C语言数据结构双向循环链表
最新发布
09-27
双向循环链表是一种常用的链表结构，它与单向链表相比具有更好的灵活性和操作效率。在C语言中，实现双向循环链表需要定义一个链表节点结构体，其中包含指向前驱节点和后继节点的指针，以及存储数据的成员。以下是一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值