23.双向环形链表

最新推荐文章于 2024-11-04 09:37:57 发布
最新推荐文章于 2024-11-04 09:37:57 发布
阅读量97 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/xiaochi/p/8405077.html
版权

运行截图:

  • 结点结构体 
    1 typedef struct LinkNode
2 {
3     int data;
4     struct LinkNode *pPre;
5     struct LinkNode *pNext;
6 }node,*PNODE;

     

  • 创建一个结构体保存头部和尾部 
    typedef struct info
{
    node *head;//指向头部
    node *tail;//指向尾部
}DList;

     

  • 初始化环形链表 
    1 void init(DList *p)
2 {
3     p->head = NULL;
4     p->tail = NULL;
5 }

     

  •  1 //在链表尾部插入数据
 2 void addDataBack(DList *p, int data)
 3 {
 4     //创建一个新的结点
 5     node *pnew = (node *)malloc(sizeof(node));
 6     pnew->data = data;
 7     pnew->pNext = NULL;
 8     pnew->pPre = NULL;
 9 
10     //如果链表为空
11     if (p->head == NULL || p->tail == NULL)
12     {
13         //插入一个结点
14         p->tail = p->head = pnew;
15         pnew->pPre = pnew->pNext = pnew;
16     }
17     //如果只有一个结点
18     else if(p->head == p->tail)
19     {
20         p->head->pPre = pnew;
21         p->head->pNext = pnew;
22 
23         pnew->pPre = p->head;
24         pnew->pNext = p->head;
25 
26         p->tail = pnew;//保存尾部
27     }
28     //如果大于一个结点
29     else
30     {
31         pnew->pPre = p->tail;
32         pnew->pNext = p->head;
33 
34         p->tail->pNext = pnew;
35         p->head->pPre = pnew;
36 
37         p->tail = pnew;
38     }
39 }

     

  • 在链表头部插入数据 
     1 void addDataHead(DList *p, int data)
 2 {
 3     //创建一个新的结点
 4     PNODE pnew = (PNODE)malloc(sizeof(node));
 5     pnew->data = data;
 6     pnew->pNext = NULL;
 7     pnew->pPre = NULL;
 8 
 9     //如果链表为空
10     if (p->head == NULL && p->tail == NULL)
11     {
12         p->tail = p->head = pnew;
13         pnew->pPre = pnew->pNext = pnew;
14     }
15     //如果只有一个结点
16     else if (p->head == p->tail)
17     {
18         pnew->pPre = pnew->pNext = p->head;
19         p->head->pNext = p->head->pPre = pnew;
20 
21         p->head = pnew;
22     }
23     //如果大于一个结点
24     else
25     {
26         pnew->pPre = p->tail;
27         pnew->pNext = p->head;
28 
29         p->head->pPre = pnew;
30         p->tail->pNext = pnew;
31 
32         p->head = pnew;
33     }
34 }

     

  • 查询数据 
     1 //查询数据
 2 PNODE find(DList *p, int data)
 3 {
 4     if (p->head == NULL || p->tail == NULL)
 5     {
 6         return NULL;
 7     }
 8     else if (p->head == p->tail)
 9     {
10         PNODE pl = p->head;
11         if (pl->data == data)
12         {
13             return pl;
14         }
15         else
16         {
17             return NULL;
18         }
19     }
20     else
21     {
22         PNODE pl = p->head;
23         for (; pl->pNext != p->head; pl = pl->pNext)
24         {
25             if (pl->data == data)
26             {
27                 return pl;
28             }
29         }
30         //尾部补充一个
31         if (pl->data == data)
32         {
33             return pl;
34         }
35         else
36         {
37             return NULL;
38         }
39     }
40 }

     

  • 改变一个结点的数据 
    void change(DList *p, int data,int newdata)
{
    if (p->head == NULL || p->tail == NULL)
    {
        return;
    }
    //如果只有一个结点
    else if (p->head == p->tail)
    {
        PNODE pl = p->head;
        if (pl->data == data)
        {
            pl->data == newdata;
        }
    }
    //如果大于一个结点
    else
    {
        PNODE pl = p->head;
        for (; pl->pNext != p->head; pl = pl->pNext)
        {
            if (pl->data == data)
            {
                pl->data == newdata;
            }
        }
        //尾部补充一个
        if (pl->data == data)
        {
            pl->data == newdata;
        }
    }
}

     

  • 删除一个结点 
     1 void deleteData(DList *p, int data)
 2 {
 3     //先判断只有一个结点的情况
 4     if (p->head == p->tail)
 5     {
 6         if (p->head->data == data)
 7         {
 8             free(p->head);
 9             p->head = NULL;
10             p->tail = NULL;
11         }
12     }
13     //结点个数大于1
14     else
15     {
16         //备份头结点
17         PNODE pl = p->head;
18         //先判断是不是头结点
19         if (pl->data == data)
20         {
21             pl->pNext->pPre = p->tail;
22             p->tail->pNext = pl->pNext;
23             p->head = pl->pNext;
24             free(pl);
25         }
26         //如果不是头结点
27         else
28         {
29             //一直从后一个遍历到结束
30             pl = pl->pNext;
31             while (pl != p->head)
32             {
33                 if (pl->data == data)
34                 {
35                     break;
36                 }
37                 else
38                 {
39                     pl = pl->pNext;
40                 }
41             }
42             //如果找到了
43             if (pl != p->head)
44             {
45                 //如果循环到尾部
46                 if (pl == p->tail)
47                 {
48                     pl->pPre->pNext = p->head;
49                     p->head->pPre = pl->pPre;
50 
51                     p->tail = pl->pPre;
52                     free(pl);
53                 }
54                 //如果在中间
55                 else
56                 {
57                     pl->pNext->pPre = pl->pPre;
58                     pl->pPre->pNext = pl->pNext;
59                     free(pl);
60                 }
61             }
62         }
63     }
64     
65 }

     

完整代码:

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 
  4 //双链表节点
  5 typedef struct LinkNode
  6 {
  7     int data;
  8     struct LinkNode *pPre;
  9     struct LinkNode *pNext;
 10 }node,*PNODE;
 11 
 12 //创建一个结构体保存头部和尾部
 13 typedef struct info
 14 {
 15     node *head;//指向头部
 16     node *tail;//指向尾部
 17 }DList;
 18 
 19 void init(DList *p)
 20 {
 21     p->head = NULL;
 22     p->tail = NULL;
 23 }
 24 
 25 //在链表尾部插入数据
 26 void addDataBack(DList *p, int data)
 27 {
 28     //创建一个新的结点
 29     node *pnew = (node *)malloc(sizeof(node));
 30     pnew->data = data;
 31     pnew->pNext = NULL;
 32     pnew->pPre = NULL;
 33 
 34     //如果链表为空
 35     if (p->head == NULL || p->tail == NULL)
 36     {
 37         //插入一个结点
 38         p->tail = p->head = pnew;
 39         pnew->pPre = pnew->pNext = pnew;
 40     }
 41     //如果只有一个结点
 42     else if(p->head == p->tail)
 43     {
 44         p->head->pPre = pnew;
 45         p->head->pNext = pnew;
 46 
 47         pnew->pPre = p->head;
 48         pnew->pNext = p->head;
 49 
 50         p->tail = pnew;
 51     }
 52     //如果大于一个结点
 53     else
 54     {
 55         pnew->pPre = p->tail;
 56         pnew->pNext = p->head;
 57 
 58         p->tail->pNext = pnew;
 59         p->head->pPre = pnew;
 60 
 61         p->tail = pnew;
 62     }
 63 }
 64 
 65 //在链表头部插入数据
 66 void addDataHead(DList *p, int data)
 67 {
 68     //创建一个新的结点
 69     PNODE pnew = (PNODE)malloc(sizeof(node));
 70     pnew->data = data;
 71     pnew->pNext = NULL;
 72     pnew->pPre = NULL;
 73 
 74     //如果链表为空
 75     if (p->head == NULL && p->tail == NULL)
 76     {
 77         p->tail = p->head = pnew;
 78         pnew->pPre = pnew->pNext = pnew;
 79     }
 80     //如果只有一个结点
 81     else if (p->head == p->tail)
 82     {
 83         pnew->pPre = pnew->pNext = p->head;
 84         p->head->pNext = p->head->pPre = pnew;
 85 
 86         p->head = pnew;
 87     }
 88     //如果大于一个结点
 89     else
 90     {
 91         pnew->pPre = p->tail;
 92         pnew->pNext = p->head;
 93 
 94         p->head->pPre = pnew;
 95         p->tail->pNext = pnew;
 96 
 97         p->head = pnew;
 98     }
 99 }
100 
101 //查询数据
102 PNODE find(DList *p, int data)
103 {
104     if (p->head == NULL || p->tail == NULL)
105     {
106         return NULL;
107     }
108     else if (p->head == p->tail)
109     {
110         PNODE pl = p->head;
111         if (pl->data == data)
112         {
113             return pl;
114         }
115         else
116         {
117             return NULL;
118         }
119     }
120     else
121     {
122         PNODE pl = p->head;
123         for (; pl->pNext != p->head; pl = pl->pNext)
124         {
125             if (pl->data == data)
126             {
127                 return pl;
128             }
129         }
130         //尾部补充一个
131         if (pl->data == data)
132         {
133             return pl;
134         }
135         else
136         {
137             return NULL;
138         }
139     }
140 }
141 
142 //改变一个结点的数据
143 void change(DList *p, int data,int newdata)
144 {
145     if (p->head == NULL || p->tail == NULL)
146     {
147         return;
148     }
149     //如果只有一个结点
150     else if (p->head == p->tail)
151     {
152         PNODE pl = p->head;
153         if (pl->data == data)
154         {
155             pl->data == newdata;
156         }
157     }
158     //如果大于一个结点
159     else
160     {
161         PNODE pl = p->head;
162         for (; pl->pNext != p->head; pl = pl->pNext)
163         {
164             if (pl->data == data)
165             {
166                 pl->data == newdata;
167             }
168         }
169         //尾部补充一个
170         if (pl->data == data)
171         {
172             pl->data == newdata;
173         }
174     }
175 }
176 
177 //删除一个结点
178 void deleteData(DList *p, int data)
179 {
180     //先判断只有一个结点的情况
181     if (p->head == p->tail)
182     {
183         if (p->head->data == data)
184         {
185             free(p->head);
186             p->head = NULL;
187             p->tail = NULL;
188         }
189     }
190     //结点个数大于1
191     else
192     {
193         //备份头结点
194         PNODE pl = p->head;
195         //先判断是不是头结点
196         if (pl->data == data)
197         {
198             pl->pNext->pPre = p->tail;
199             p->tail->pNext = pl->pNext;
200             p->head = pl->pNext;
201             free(pl);
202         }
203         //如果不是头结点
204         else
205         {
206             //一直从后一个遍历到结束
207             pl = pl->pNext;
208             while (pl != p->head)
209             {
210                 if (pl->data == data)
211                 {
212                     break;
213                 }
214                 else
215                 {
216                     pl = pl->pNext;
217                 }
218             }
219             //如果找到了
220             if (pl != p->head)
221             {
222                 //如果循环到尾部
223                 if (pl == p->tail)
224                 {
225                     pl->pPre->pNext = p->head;
226                     p->head->pPre = pl->pPre;
227 
228                     p->tail = pl->pPre;
229                     free(pl);
230                 }
231                 //如果在中间
232                 else
233                 {
234                     pl->pNext->pPre = pl->pPre;
235                     pl->pPre->pNext = pl->pNext;
236                     free(pl);
237                 }
238             }
239         }
240     }
241     
242 }
243 
244 void insert(DList *p, int data, int newdata)
245 {
246     PNODE pnew = (PNODE)malloc(sizeof(node));//开辟节点
247     pnew->data = newdata;
248     pnew->pNext = NULL;
249     pnew->pPre = NULL;
250 
251     //从头结点开始向后找    
252     PNODE pl = p->head;
253     while (pl->pNext != p->head)
254     {
255         if (pl->data == data)
256         {
257             break;
258         }
259         else
260         {
261             pl = pl->pNext;
262         }
263     }
264     //后面插入
265     //无论最后一个结点是不是要找的结点都插在后面
266     //只有一个结点,插在尾部
267     if (pl == p->head && p->tail == pl)
268     {
269         pnew->pPre = pnew->pNext = p->head;
270         p->head->pNext = p->head->pPre = pnew;
271         p->tail = pnew;
272     }
273     //如果遍历到尾部结点
274     else if (pl == p->tail && pl != p->head)
275     {
276         pnew->pNext = p->head;
277         pnew->pPre = p->tail;
278 
279         p->tail->pNext = pnew;
280         p->head->pPre = pnew;
281 
282         p->tail = pnew;
283     }
284     //如果不在尾结点
285     else
286     {
287         pnew->pPre = pl;
288         pnew->pNext = pl->pNext;
289         
290         pl->pNext->pPre = pnew;
291         pl->pNext = pnew;
292     }
293 }
294 
295 
296 //显示链表的数据
297 void show(DList *p)
298 {
299 
300     if (p->head == NULL || p->tail == NULL)
301     {
302         return;
303     }
304     else if (p->head == p->tail)
305     {
306         PNODE pl = p->head;
307         printf("%d,(CurAddr)%p,(PreAddr)%p,(NextAddr)%p\n", pl->data, pl, pl->pPre, pl->pNext);
308     }
309     else
310     {
311         PNODE pl = p->head;
312         for (; pl->pNext != p->head; pl = pl->pNext)
313         {
314             printf("%d,(CurAddr)%p,(PreAddr)%p,(NextAddr)%p\n", pl->data, pl, pl->pPre, pl->pNext);
315         }
316         //尾部补充一个
317         printf("%d,(CurAddr)%p,(PreAddr)%p,(NextAddr)%p\n", pl->data, pl, pl->pPre, pl->pNext);
318     }
319 }
320 
321 
322 
323 void main()
324 {
325     DList dlist;
326     init(&dlist);
327 
328     for (int i = 0; i < 5; i++)
329     {
330         addDataHead(&dlist,i);
331         //addDataBack(&dlist, i);
332         printf("\n\n");
333         show(&dlist);
334     }
335 
336     //查询数据并修改
337     PNODE px = find(&dlist, 3);
338     px->data = 19;
339     printf("\n\n");
340 
341     //后插数据
342     insert(&dlist, 1, 100);
343     printf("\n\n");
344     show(&dlist);
345 
346     //删除数据
347     deleteData(&dlist, 4);
348     printf("\n\n");
349     show(&dlist);
350     system("pause");
351 }

 

转载于:https://www.cnblogs.com/xiaochi/p/8405077.html

weixin_30593261
关注
学习笔记-双向链表与环形链表
touteng55的博客
02-17 285
双向链表 在单链表的基础上，每个节点增加了一个pre属性指向前一个节点。 因为单链表只有next指针，因此只能单向遍历。而双向链表可以从前或从后遍历。另外也可以自我删除，也就是不用借助被删节点的前一个节点进行删除，直接靠自己就行。 增删改查 节点增加了pre指向前一个节点 //双向链表的节点 class StudentNode2{ public int no; public String name; StudentNode2 next; StudentNode2 pre;
java基于双向环形链表解决丢手帕问题的方法示例
08-28
Java基于双向环形链表解决丢手帕问题的方法示例 Java基于双向环形链表解决丢手帕问题的方法示例主要介绍了如何使用Java语言来解决丢手帕问题。丢手帕问题是一个经典的算法问题，描述了小孩围坐一圈，按顺序报数，...
用c语言创建双向环形链表
weixin_30263277的博客
11-18 191
作为一个C开发人员，无论在求职笔试题中，还是在工程项目中，都会遇到用c语言创建双向环形链表。这个也是理解和使用c指针的一项基本功。 #include<...>//头文件省略 typedef struct ringbuf_str{ unsigned int ringID; /* ring ID*/ struct ringbuf_str *next; /* Next ring...
golang实现单向，双向，环形单向链表：增（两种方式）删改查，链表所有结点展示...双向链表，环形单项链表完整代码
weixin_31501115的博客
08-10 419
【代码】golang实现单链表：增（两种方式）删改查，链表所有结点展示....双向链表完整代码，环形单项链表完整代码
单向.双向.环形链表的基本操作--风之java
风生的博客
08-13 1288
链表单项链表增加删除查找更改插入反转链表双向链表增加删除查找更改插入环形链表约瑟夫问题 单项链表 逻辑结构图： 先创建一个节点类： 为了简化代码链表中的真实数据均整形data表示，并用Num（Num从1开始）记录对应的下标。 public class Node { int data;//链表中的真实数据 int Num;//对应下标 Node next;//指针 public Node(){} public Node(int data){ thi
数据结构算法——1007. 环形双向链表的删除操作(待精简
JamSlade的博客
09-13 516
题目 思路 搞清楚环形链表在 开头、 中部、结尾 ，以及链表是否为空？单个元素？多个元素？插入和删除的情况 代码有待精简 代码（未精简 #include<iostream> using namespace std; typedef long long ll; struct node { ll data; node* next; node* prev; node() { data = 0; next = NULL;
数据结构与算法-双向环形链表
AABFF的博客
05-11 541
例如，如果在插入一个节点之后，后一个节点指向的地址已经被占用，那么就需要将后一个节点的指针指向前一个节点，从而释放后一个节点的空间。如果在删除一个节点之后，前一个节点指向的地址已经被占用，那么就需要将前一个节点的指针指向后一个节点，从而释放前一个节点的空间。双向环形链表（Doubly-Linked List）是一种常见的链表数据结构，它具有两个方向的指针，一个指向前一个节点，另一个指向后一个节点。3、双向环形链表的空间利用率较高，因为每个节点只需要存储前一个节点和后一个节点的指针，而不需要存储节点的值。
链表—24. 两两交换链表中的节点 234.回文链表 143.重排链表 141.环形链表 142.环形链表II 160.链表相交 C++实现
UUUUU22的博客
07-06 200
链表专题1—24. 两两交换链表中的节点 234.回文链表 143.重排链表 141.环形链表 142.环形链表II 160.链表相交 C++实现
Java-实现双向环形链表
Broken_x的博客
09-10 631
双向环形链表不仅支持双向遍历，还形成一个闭合环，即最后一个节点的next指针指向链表的头部，第一个节点的prev指针指向链表的尾部。使用这种结构可以实现更加灵活的循环遍历操作。双向环形链表是编程中一种强大且灵活的数据结构，它可用于在循环访问中保持高效。通过合理设计Node结构和使用哨兵节点，我们简化了边界条件的处理，提供了更直观的操作方法。希望对你有所帮助。
C语言：带头双向环形链表
aiyubaobei的博客
11-25 880
双向循环链表 上一次我们讲了单向无头非循环链表的实现，单向无头非循环链表的特点是：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构。而带头双向循环链表则恰恰与无头单向非循环链表相反，它的结构最复杂，一般用来单独存储数据。这个结构虽然复杂，但是使用单吗实现后会发现，这个结构用起来很简单。 结构示意图 带头双向循环链表在逻辑上大概就是这样的一个样子，链表的最后一个节点的后继指向的是头结点。而头结点的前驱则是指向链表的最后一个结点。所以，一个空的带头双向循环链表的逻辑结构应该是这样的：
基础数据结构——双向环形链表（带哨兵节点）
xuziang13的博客
10-10 340
双向环形链表带哨兵，这时哨兵既作为头，也作为尾。和之前一样，我们先设立通用节点Node的属性以及有参构造接着我们来写哨兵节点。因为哨兵节点只有在实例化之后才可以操作，所以我们先实例化一个初始哨兵节点，再通过构造方法给该哨兵节点完成环形连接。代码如下;这样我们就创建了双向环形链表。
lianbiao.rar_链表
09-23
4. **循环链表**：最后一个节点的指针会回指到链表的第一个节点，形成一个环形结构，这样的链表称为循环链表。 5. **链表的创建**：创建链表通常从创建一个空头节点开始，然后逐步添加节点。例如，可以使用`new`...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 461
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
查找算法简记
well_fly的博客
10-30 609
简单记录查找算法相关知识点
C++算法第五天
2302_80418176的博客
10-31 1057
1. 首这个解法叫滑动窗口，本质是同向双指针2. 使用这个解法的原因是利用了单调性3.滑动窗口的正确性：利用的单调性，规避了没必要的枚举行为4.枚举二字算是在博主的文章中第一次出现，那么我也解释枚举是什么意思，枚举就是将每一种情况都一一列举出来。
模拟退火算法求解TSP问题
最新发布
m0_56408077的博客
11-04 335
模拟退火算法（Simulated Annealing, SA）是一种通用的随机优化算法，适合解决组合优化问题，如旅行商问题（TSP）。TSP 问题的目标是给定一组城市，找到一条闭合路径，使得旅行商从一个城市出发，访问每个城市恰好一次并最终返回起点，同时路径总长度最短。
实习冲刺Day11
2301_78814687的博客
11-02 315
c++中字符串有两种存储方式，一种是存储在char[]数组中，一种是存储在c++封装的string类中。在C中也可以使用字符指针来访问一个字符串,通过字符指针指向存放字符串数组的首元素地址来进行访问.在C中，并没有字符串这个数据类型，而是使用。char[]来保存字符串。二叉树的先序遍历根左右。二叉树的后序遍历左右根。
echarts 遍历多个图表，并添加resize缩放
licongmingli的博客
10-30 242
遍历echarst多个图表，并添加独立的缩放函数
双向环形链表的实际用途
08-18
双向环形链表是一种特殊的链表结构，它允许每个节点除了拥有指向下一个节点的指针外，还有一个指向前一个节点的指针，形成一个首尾相连的闭环。这种数据结构有以下几个实际应用场景： 1. **缓存淘汰策略**：在某些需要频繁插入和删除元素的数据结构中，如LRU (Least Recently Used) 缓存算法，双向环形链表可以方便地替换掉最久未使用的元素。 2. **音乐播放列表**：在音乐播放软件中，如果需要创建无缝循环播放的功能，双向环形链表可以用来表示歌曲列表，使得播放从头开始也能无缝连接到列表尾部。 3. **游戏状态管理**：在一些游戏中，特别是回合制或实时战略游戏，可能会使用双向环形队列来模拟战斗序列，保证战斗的顺序性和可回溯性。 4. **数据流处理**：在网络编程中，双向环形链表可以用于消息队列系统，新消息添加到头部，旧的消息可以从尾部移除，同时保持队列的循环属性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值