算法：C实现一个环形链表

已于 2022-01-24 15:12:53 修改
阅读量825 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 链表 算法 c语言
于 2020-12-14 14:59:41 首次发布
原文链接：https://github.com/acl-dev/demo
版权

实现

初始化链表的哨兵节点

1、需要什么？

  • 链表的首地址

2、无需返回值

3、怎么做：
(1) 如果链表的首地址为NULL，直接返回；否则跳到(2)
(2)令ring的前驱后续以及parent都指向ring，以及初始化ring.len = 0

void acl_ring_init(ACL_RING *ring){
    if(ring == NULL){
        return;
    }

    ring->pred = ring->succ = ring;
    ring->parent = ring;
    ring->len = 0;
}

获取当前数据环元素个数

1、需要什么？

  • 链表的首地址

2、返回数组个数

3、怎么做：
(1) 如果链表的首地址为NULL，直接返回-1；否则跳到(2)
(2) 返回ring.len

将一个新元素添加进环的头部

1、需要什么

  • 链表的首地址
  • 待添加的环地址entry

2、无需返回值

3、怎么做：
(1) 如果环为NULL或者新元素为NULL直接返回
(2) 令 entry的后继指向哨兵节点的后继（则哨兵节点后继的前驱为entry）
令entry的前驱指向哨兵节点（则哨兵节点的后继为entry）
令entry.parent = ring.parent, ring.parent.len++

void acl_ring_append(ACL_RING *ring, ACL_RING *entry)
{
	if (ring == NULL || entry == NULL)
		return;
	entry->succ      = ring->succ;
	entry->pred      = ring;
	entry->parent    = ring->parent;
	ring->succ->pred = entry;
	ring->succ       = entry;
	ring->parent->len++;
}

将一个新元素添加进环的尾部

1、需要什么

  • 链表的首地址
  • 待添加的环地址entry

2、无需返回值

3、怎么做：
(1) 如果环为NULL或者新元素为NULL直接返回
(2) 令 entry的前驱指向哨兵节点的后继（则哨兵节点后继的前驱为entry）
令entry的后继指向哨兵节点（则哨兵节点的前驱为entry）
令entry.parent = ring.parent, ring.parent.len++

  void acl_ring_prepend(ACL_RING *ring, ACL_RING *entry)
{
	if (ring == NULL || entry == NULL)
		return;
	entry->pred      = ring->pred;
	entry->succ      = ring;
	entry->parent    = ring->parent;
	ring->pred->succ = entry;
	ring->pred       = entry;
	ring->parent->len++;
}

将一个环元素从数据环中删除

1、需要什么
待删除元素的地址entry

2、无需返回值

3、怎么做
（1）如果entry为NULL或者entry为哨兵节点，直接返回
（2）取得entry的前驱与后继

  • 如果前驱或者后继为NULL（环只有哨兵节点，还没有其他数据），直接返回
  • 令entry的前驱的后继指向后继；后继的前驱指向前驱

（3）令entry.parent.len++；entry的前驱、后继、parent都指向自身、entry.len = 0

void acl_ring_detach(ACL_RING *entry)
{
	ACL_RING   *succ;
	ACL_RING   *pred;

	if (entry == NULL || entry->parent == entry)
		return;
	succ = entry->succ;
	pred = entry->pred;
	if (succ == NULL || pred == NULL)
		return;
	pred->succ = succ;
	succ->pred = pred;

	entry->parent->len--;

	entry->succ = entry->pred = entry;
	entry->parent = entry;
	entry->len = 0;
}

从环中弹出头部环元素

1、需要什么：

  • 环地址

2、返回值：

  • 头部环元素，如果返回NULL表示该数据环为NULL

3、怎么做
（1）如果ring=NULL，返回NULL
（2）取出ring的后继，如果后继为NULL，则直接返回；否则跳到（3）
（3）将后继从环中删除，然后返回这个元素

ACL_RING *acl_ring_pop_head(ACL_RING *ring)
{
	ACL_RING   *succ;

	if (ring == NULL)
		return NULL;

	succ = ring->succ;
	if (succ == ring)
		return NULL;

	acl_ring_detach(succ);

	return succ;
}

从环中弹出尾部环元素

ACL_RING *acl_ring_pop_tail(ACL_RING *ring)
{
	ACL_RING   *pred;

	if (ring == NULL)
		return NULL;

	pred = ring->pred;
	if (pred == ring)
		return NULL;

	acl_ring_detach(pred);

	return pred;
}

总结

#include <lzma.h>
#include "acl_ring.h"
/* acl_ring_init - initialize ring head */
void acl_ring_init(ACL_RING *ring)
{
    if (ring == NULL)
        return;
    ring->pred   = ring->succ = ring;
    ring->parent = ring;
    ring->len    = 0;
}

/* acl_ring_size - the entry number in the ring */

int acl_ring_size(const ACL_RING *ring)
{
    if (ring == NULL)
        return -1;

    return ring->len;
}

/* acl_ring_append - insert entry after ring head */

void acl_ring_append(ACL_RING *ring, ACL_RING *entry)
{
    if (ring == NULL || entry == NULL)
        return;
    entry->succ      = ring->succ;
    entry->pred      = ring;
    entry->parent    = ring->parent;
    ring->succ->pred = entry;
    ring->succ       = entry;
    ring->parent->len++;
}

/* acl_ring_prepend - insert new entry before ring head */
void acl_ring_prepend(ACL_RING *ring, ACL_RING *entry)
{
    if (ring == NULL || entry == NULL)
        return;
    entry->pred      = ring->pred;
    entry->succ      = ring;
    entry->parent    = ring->parent;
    ring->pred->succ = entry;
    ring->pred       = entry;
    ring->parent->len++;
}

/* acl_ring_detach - remove entry from ring */

void acl_ring_detach(ACL_RING *entry)
{
    ACL_RING   *succ;
    ACL_RING   *pred;

    if (entry == NULL || entry->parent == entry)
        return;
    succ = entry->succ;
    pred = entry->pred;
    if (succ == NULL || pred == NULL)
        return;
    pred->succ = succ;
    succ->pred = pred;

    entry->parent->len--;

    entry->succ = entry->pred = entry;
    entry->parent = entry;
    entry->len = 0;
}

/* acl_ring_pop_head - pop ring's head entry out from ring */

ACL_RING *acl_ring_pop_head(ACL_RING *ring)
{
    ACL_RING   *succ;

    if (ring == NULL)
        return NULL;

    succ = ring->succ;
    if (succ == ring)
        return NULL;

    acl_ring_detach(succ);

    return succ;
}

/* acl_ring_pop_tail - pop ring's tail entry out from ring */

ACL_RING *acl_ring_pop_tail(ACL_RING *ring)
{
    ACL_RING   *pred;

    if (ring == NULL)
        return NULL;

    pred = ring->pred;
    if (pred == ring)
        return NULL;

    acl_ring_detach(pred);

    return pred;
}

acl_ring.h

#pragma once
#include <stddef.h>
typedef struct ACL_RING ACL_RING;

/**
 * 数据环结构类型定义
 */
struct ACL_RING {
    ACL_RING *succ;           /**< successor */
    ACL_RING *pred;           /**< predecessor */

    ACL_RING *parent;         /**< the header of all the rings */
    int len;                  /**< the count in the ring */
};

typedef struct ACL_RING_ITER {
    ACL_RING *ptr;
} ACL_RING_ITER;


/**
 * 初始化数据环
 * @param ring {ACL_RING*} 数据环
 */
void acl_ring_init(ACL_RING *ring);
/**
 * 获得当前数据环内元素个数
 * @param ring {ACL_RING*} 数据环
 * @return {int} 数据环内元素个数
 */
 int  acl_ring_size(const ACL_RING *ring);

/**
 * 将一个新元素添加进环的头部
 * @param ring {ACL_RING*} 数据环
 * @param entry {ACL_RING*} 新的元素
 */
void acl_ring_prepend(ACL_RING *ring, ACL_RING *entry);

/**
 * 将一个新元素添加进环的尾部
 * @param ring {ACL_RING*} 数据环
 * @param entry {ACL_RING*} 新的元素
 */
void acl_ring_append(ACL_RING *ring, ACL_RING *entry);

/**
 * 将一个环元素从数据环中删除
 * @param entry {ACL_RING*} 环元素
 */
void acl_ring_detach(ACL_RING *entry);

/**
 * 从环中弹出头部环元素
 * @param ring {ACL_RING*} 数据环
 * @return {ACL_RING*} 头部环元素，如果返回空则表示该数据环为空
 */
ACL_RING *acl_ring_pop_head(ACL_RING *ring);

/**
 * 从环中弹出尾部环元素
 * @param ring {ACL_RING*} 数据环
 * @return {ACL_RING*} 尾部环元素，如果返回空则表示该数据环为空
 */
ACL_RING *acl_ring_pop_tail(ACL_RING *ring);

/*--------------------  一些方便快捷的宏操作 --------------------------------*/

/**
 * 返回当前环元素的下一个环元素
 */
#define ACL_RING_SUCC(c) ((c)->succ)
#define	acl_ring_succ	ACL_RING_SUCC

/**
 * 返回当前环元素的前一个环元素
 */
#define ACL_RING_PRED(c) ((c)->pred)
#define	acl_ring_pred	ACL_RING_PRED

/**
 * 将环元素指针转换成应用的自定义类型的指针地址
 * @param ring_ptr {ACL_RING*} 环元素指针
 * @param app_type 应用自定义类型
 * @param ring_member {ACL_RING*} 环元素在应用自定义结构中的成员名称
 * @return {app_type*} 应用自定义结构类型的对象地址
 */
#define ACL_RING_TO_APPL(ring_ptr, app_type, ring_member) \
    ((app_type *) (((char *) (ring_ptr)) - offsetof(app_type,ring_member)))

#define	acl_ring_to_appl	ACL_RING_TO_APPL


#define	ACL_RING_FOREACH(iter, head_ptr) \
        for ((iter).ptr = acl_ring_succ((head_ptr)); (iter).ptr != (head_ptr);  \
             (iter).ptr = acl_ring_succ((iter).ptr))

#define	acl_ring_foreach		ACL_RING_FOREACH

/**
 * 从尾部至头部遍历数据环中的所有环元素
 * @param iter {ACL_RING_ITER}
 * @param head_ptr {ACL_RING*} 数据环的头指针
 */
#define	ACL_RING_FOREACH_REVERSE(iter, head_ptr) \
        for ((iter).ptr = acl_ring_pred((head_ptr)); (iter).ptr != (head_ptr);  \
             (iter).ptr = acl_ring_pred((iter).ptr))

#define	acl_ring_foreach_reverse	ACL_RING_FOREACH_REVERSE

/**
 * 返回数据环中第一个环元素指针
 * @param head {ACL_RING*} 环头指针
 * @return {ACL_RING*} NULL: 环为空
 */
#define ACL_RING_FIRST(head) \
	(acl_ring_succ(head) != (head) ? acl_ring_succ(head) : 0)

#define	acl_ring_first		ACL_RING_FIRST

/**
 * 返回数据环中头第一个环元素指针同时将其转换应用自定义结构类型的对象地址
 * @param head {ACL_RING*} 环头指针
 * @param app_type 应用自定义结构类型
 * @param ring_member {ACL_RING*} 环元素在应用自定义结构中的成员名称
 * @return {app_type*} 应用自定义结构类型的对象地址
 */
#define ACL_RING_FIRST_APPL(head, app_type, ring_member) \
	(acl_ring_succ(head) != (head) ? \
	 ACL_RING_TO_APPL(acl_ring_succ(head), app_type, ring_member) : 0)

#define	acl_ring_first_appl	ACL_RING_FIRST_APPL

/**
 * 返回数据环中最后一个环元素指针
 * @param head {ACL_RING*} 环头指针
 * @return {ACL_RING*} NULL: 环为空
 */
#define ACL_RING_LAST(head) \
       (acl_ring_pred(head) != (head) ? acl_ring_pred(head) : 0)

#define	acl_ring_last		ACL_RING_LAST

/**
 * 返回数据环中最后一个环元素指针同时将其转换应用自定义结构类型的对象地址
 * @param head {ACL_RING*} 环头指针
 * @param app_type 应用自定义结构类型
 * @param ring_member {ACL_RING*} 环元素在应用自定义结构中的成员名称
 * @return {app_type*} 应用自定义结构类型的对象地址
 */
#define ACL_RING_LAST_APPL(head, app_type, ring_member) \
       (acl_ring_pred(head) != (head) ? \
	ACL_RING_TO_APPL(acl_ring_pred(head), app_type, ring_member) : 0)

#define	acl_ring_last_appl	ACL_RING_LAST_APPL

/**
 * 将一个新元素添加进环的尾部
 * @param ring {ACL_RING*} 数据环
 * @param entry {ACL_RING*} 新的元素
 */
#define	ACL_RING_APPEND(ring_in, entry_in) do {  \
	ACL_RING *ring_ptr = (ring_in), *entry_ptr = (entry_in);  \
        entry_ptr->succ      = ring_ptr->succ;  \
        entry_ptr->pred      = ring_ptr;  \
        entry_ptr->parent    = ring_ptr->parent;  \
        ring_ptr->succ->pred = entry_ptr;  \
        ring_ptr->succ       = entry_ptr;  \
        ring_ptr->parent->len++;  \
} while (0)

/**
 * 将一个新元素添加进环的头部
 * @param ring {ACL_RING*} 数据环
 * @param entry {ACL_RING*} 新的元素
 */
#define	ACL_RING_PREPEND(ring_in, entry_in) do {  \
	ACL_RING *ring_ptr = (ring_in), *entry_ptr = (entry_in);  \
	entry_ptr->pred      = ring_ptr->pred;  \
	entry_ptr->succ      = ring_ptr;  \
	entry_ptr->parent    = ring_ptr->parent;  \
	ring_ptr->pred->succ = entry_ptr;  \
	ring_ptr->pred       = entry_ptr;  \
	ring_ptr->parent->len++;  \
} while (0)

/**
 * 将一个环元素从数据环中删除
 * @param entry {ACL_RING*} 环元素
 */
#define	ACL_RING_DETACH(entry_in) do {  \
	ACL_RING   *succ, *pred, *entry_ptr = (entry_in);  \
	succ = entry_ptr->succ;  \
	pred = entry_ptr->pred;  \
	if (succ != NULL && pred != NULL) {  \
		pred->succ = succ;  \
		succ->pred = pred;  \
		entry_ptr->parent->len--;  \
		entry_ptr->succ = entry_ptr->pred = NULL;  \
	}  \
} while (0)

3、main.c

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

typedef struct {
    char  name[32];
    ACL_RING entry;
} DUMMY;

void test()
{
    ACL_RING head;
    DUMMY *dummy;
    ACL_RING_ITER iter;
    int   i;

    acl_ring_init(&head);

    for (i = 0; i < 10; i++) {
        dummy = (DUMMY*) calloc(1, sizeof(DUMMY));
        snprintf(dummy->name, sizeof(dummy->name), "dummy:%d", i);
        acl_ring_append(&head, &dummy->entry);
    }

    acl_ring_foreach(iter, &head) {
        dummy = acl_ring_to_appl(iter.ptr, DUMMY, entry);
        printf("name: %s\n", dummy->name);
    }

    while (1) {
        iter.ptr = acl_ring_pop_head(&head);
        if (iter.ptr == NULL)
            break;
        dummy = acl_ring_to_appl(iter.ptr, DUMMY, entry);
        free(dummy);
    }
}
int main(void)
{
    test();
    return 0;
}
OceanStar的学习笔记
关注
专栏目录
JAVA:实现CircularBuffer环形缓冲器算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-09 567
JAVA:实现CircularBuffer环形缓冲器算法(附完整源码)
约瑟夫问题——环形链表实现
weixin_41304904的博客
03-18 710
1. 约瑟夫问题 约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3，1。 2. 思路分析 采用环形链表的方式，该链表中存储first结点与cur结点，分别表示第一个人与最后一个人，其中cur.next = first，即最后一个人指向第一个人。 采取循环的方式进行，设置计数器times...
C语言——环形链表
qq_62476499的博客
01-09 1063
leetcode上的题目：环形链表入口
Leetcode(Java)-142. 环形链表 II
Slayer_Zhao的博客
02-10 184
给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 说明：不允许修改给定的链表。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：tail connects to node inde...
leetcode[141]：环形链表 C语言解法
Deep_l_zh的博客
03-24 881
给定一个链表，判断链表中是否有环。 为了表示给定链表中的环，我们使用整数pos来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果pos是-1，则在该链表中没有环。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。 示例2： 输入：head = [1,2], pos =...
力扣 141. 环形链表 C语言实现
ThePaK的博客
11-27 270
力扣 141. 环形链表 哈希表和快慢指针
c语言基础-c语言编程基础之链表操作示例-环形链表.zip
03-17
链表分为单链表、双链表等类型，而环形链表是其中的一种特殊形式，它的最后一个节点的指针不为NULL，而是指向链表的第一个节点，形成一个循环。 在C语言中，创建链表需要定义结构体来表示链表节点，通常包含数据域...
【实现环形数据结构的算法技巧】：JavaScript中的环形链表与循环数组
[【实现环形数据结构的算法技巧】：JavaScript中的环形链表与循环数组](https://img-blog.csdnimg.cn/949ca7557d1346b892898ed1ad06dba3.png) # 1. 环形数据结构简介与应用 ## 环形数据结构概念 环形数据结构是一种...
【环形数据结构的代码复用】：编写可复用的环形链表和循环数组函数
[【环形数据结构的代码复用】：编写可复用的环形链表和循环数组函数](https://img-blog.csdnimg.cn/20210303145851528.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9...
实战演练：C语言实现有序链表合并操作
介绍：C语言实现有序链表合并操作的背景及意义 当涉及数据结构中的链表时，有序链表是一种特殊的数据结构，它在某些情况下比非有序链表更具优势。本文将探讨如何使用C语言实现有序链表的合并操作，深入剖析其背景...
C例子：循环链表
06-13
该程序是我写的博客“一起talk C栗子吧（第十四回：C语言实例--循环列表）”的配套程序，共享给大家使用
c语言简单循环链表
04-22
#include <stdio.h> #include <stdlib.h> int main(void) { //线性表在计算机中的存储结构是连续的 //以下是两种建立线性表的方式,可能还有更多方法 int lineTable[10]; int *ptrlineTable = (int *) malloc (sizeof(int)); free(ptrlineTable); return 0; }
环形链表专题（C语言）
Butayarou的博客
02-14 776
文章目录初阶版进阶版 初阶版 【题目描述】 给你一个链表的头节点 head ，判断链表中是否有环。 如果链表中存在环 ，则返回 true 。 否则，返回 false 。 注：环指的是链表尾连接到链表中形成的结构。 题目来源（力扣）：环形链表 【基本思路】 快慢指针法：慢指针一次走一步，快指针一次走两步。 若存在环，则快慢指针一直在环里循环直到相遇为止（由于慢指针一次走一步，快指针一次走两步，故必能相遇）。 若不存在环，则快指针先到达链表末尾。 【代码实现】 bool hasCycle(struct Li
c语言：创建环状链表
田田的博客
02-25 2294
/* 要创建一个环形链表，创建十个节点并赋值0-9，并依次输出 */ #include <stdio.h> #include <malloc.h> #define N 10 struct node { int num; struct node* next; }; struct node*create()//方法是尾插法，也就是头指针一直不变，从尾部插入创建...
c语言实现简单环形链表,C语言实现环形链表
weixin_31080717的博客
05-21 450
#includetypedef struct Linknode{int data;struct Linknode *pNext;}node,*PNODE;//尾部插入PNODE addback(PNODE phead,int data){PNODE pnew= (PNODE)malloc(sizeof(node));pnew->data=data;if(phead==NULL){//一个节点...
c语言环形链表怎么建立,循环链表怎么建立。c语言
weixin_42697609的博客
05-21 273
是的建立单向循环链表的代码：#include #include typedef struct _A{int data; struct _A *next;}A;typedef A* IA;void createDoubleLink(IA *header) {int data;IA p;printf("input data end with -1:");scanf("%d", &data...
C语言——环形链表详解
最新发布
super_coders的博客
05-12 866
在一个单链表中，链表中存在环形结构。在链表中的某个节点，可以连续通过next指针再次到达，则链表中存在环。无论slow走几步，fast走几步，追击问题关系的不是走几步，而是速度差，因为他们最终都会进环。我们回到原来的问题，fast和slow到底会不会错过。当fast走三步，slow走一步时为例：如果同时存在N是奇数且C是偶数，那么将永远追不上。但是，有没有一个可能，这种情况不存在。我们使用数学来证明一下。假设slow进环时fast跟slow的距离为Nslow走的距离为L。
C语言实现环形链表
独立开发者 | 跨境电商
08-31 7517
虽然现在开发多用Java了，闲着没事拿指针来练练手还是挺有意思的。约瑟夫的问题的解决方案有很多，可以用一个循环10不到解决，但要推导出一个公式；用一维数组加两个循环也可以，这种删除一个数据，后面元素的下标都要跟着变，不太可取。
环形链表的实现
感觉身体被掏空
12-24 640
link.h #ifndef _LINK_H #define _LINK_H struct student{ int age; char name[10]; struct student *next; }; typedef struct student info_t; extern info_t *head; #endif link.c #include "li
C语言实现约瑟夫环：一位数组与循环链表
当遍历到-1时，将索引i重置为0，实现环形循环。 2. **报数逻辑**：程序使用变量`s`记录已经报数的人数，当`s`等于`m`时，表示当前索引`i`处的人报数到`m`，需要出列。出列的序号被存储到另一个数组`b`中，同时将原...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值