c语言实现--单向循环链表操作

1，什么叫单向循环链表。单向循环链表是指在单链表的基础上，表的最后一个元素指向链表头结点，不再是为空。

2，由图可知，单向循环链表的判断条件不再是表为空了，而变成了是否到表头。

3，链表的结点表示

1 struct LNode
2 {
3     int data;
4     struct LNode * next;
5 };
6 typedef struct LNode * linklist

4，单向循环链表的操作集合，仍是defs.h里的操作集合，这里就不给出了。

5，单循环链表的初始化操作。示意图

实现：

1 #include"defs.h"
2
3 void InitList(linklist *L) //改变尾指针
4 {
5     *L = (linklist)malloc(sizeof(struct LNode)); //分配头结点
6     if (*L == NULL) //分配失败
7         exit(0);
8      (*L)->next = *L;  //指针域指向它本身
9 }

6，清空操作最終图和初始化的结果是一样的。

 1 #include"defs.h"
 2
 3 void ClearList(linklist *L) //改变尾指针
 4 {
 5      linklist p, q;
 6      *L = (*L)->next;  //先令尾指针指向头结点，不然释放最后一个结点时尾指针，无法指向头结点
 7     p = (*L)->next;  //p指向第一个结点
 8
 9      while (p != *L) //p未到表头时
10     {
11          q = p->next;
12          free(p);
13          p = q;
14      }
15      *L->next = *L; //头结点指针域指向其本身
16 }

7，DestroyList操作。撤销操作是在清空操作基础上，释放了头结点。

1 #include"defs.h"
2
3 void DestroyList(linklist *L)
4 {
5      ClearList(&L);
6      free(*L); //释放头结点
7     *L = NULL;
8 }

DestroyList.c

8，ListEmpty操作。

1 #include"defs.h"
2
3 int ListEmpty(linklist L)
4 {
5      if (L->next == L)  //指针域指向它本身，肯定就是空了，该结点即为头结点
6         return 0;
7      else
8           return 1;   //非空为1
9 }

ListEmpty.c

9，ListLength操作

 1 #include"defs.h"
 2
 3 int ListLength(linklist L)
 4 {
 5     linklist p = L->next->next;  //p指向第一个结点
 6    int j = 0;
 7
 8     while (p != L->next) //p未到表头时
 9    {
10         ++j;
11         p = p->next;
12     }
13     return j;
14 }

ListLength.c

10，GetElem操作

 1 #include"defs.h"
 2
 3 void GetElem(linklist L, int i, int *e)
 4 {
 5     linklist p = L->next ; //p指向头结点
 6    int j = 0;
 7     if (i<1 || i>ListLength(L)) //位置不合理
 8        exit(0);
 9
10     while (j < i)  //位置合理，找到第i个结点
11     {
12         ++j;
13         p = p->next;
14     }
15     *e = p->data;
16 }

GetElem.c

11，LocateElem操作

 1 #include"defs.h"
 2
 3 int LocateElem(linklist L, int e)
 4 {
 5      linklist p = L->next->next; //p指向链表第一个元素
 6     int j = 0;
 7
 8     while (p != L->next) //p未到表头时
 9     {
10          ++j;
11          if (p->data == e)
12              return j;
13          p = p->next;
14      }
15     return -1;  //未找到，返回-1
16 }

LocateElem.c

12，PriorElem操作实现

 1 #include"defs.h"
 2
 3 int PriorElem(linklist L, int cur_e, int *pri_e)
 4 {
 5     linklist p = L->next->next;  //p指向链表第一个元素
 6    linklist q;
 7
 8      while (p != L->next)
 9      {
10          q = p->next;   //q指向p的后继
11          if (q != L->next && q->data == cur_e)
12          {
13                    *pri_e = p->data;
14                     return 0;
15          }
16          p = q;
17      }
18      return 0;
19 }

PriorElem.c

13，NextElem操作实现

 1 #include"defs.h"
 2
 3 int NextElem(linklist L, int cur_e, int *Nex_e) //最后一个元素无后继
 4 {
 5     linklist p = L->next->next;  //p指向第一个结点
 6    linklist q;
 7
 8      while (p != L->next)
 9      {
10           q = p->next;
11           if (q != L->next && p->data == cur_e)
12           {
13                    *Nex_e = q->data;
14                     return 0;
15           }
16           p = q;
17      }
18      return 0;
19 }

NextElem.c

14，ListInsert操作实现

 1 #include"defs.h"
 2
 3 int ListInsert(Linklist *L, int i, int e) //在表尾插入改变尾指针
 4 {
 5     linklist p = (*L)->next;  //p指向表头
 6    linklist q, s;
 7    int j = 0;
 8
 9     if (i<1 || i>ListLength(L)+1) //插入位置不合理
10         exit(0);
11
12      while (j < i-1)  //位置合理，找到第i-1个结点
13      {
14           ++j;
15           p = p->next;
16      }
17      q  = p->next; //q指向第i个结点
18     s = (linklist)malloc(sizeof(struct LNode));
19      s->data = e;
20      s->next = q;
21      q->next = s;
22      if (p == *L)
23           *L  = s;
24 }

15，ListDelete操作实现

 1 #include"defs.h"
 2
 3 int ListDelete(linklist *L, int i, int *e)
 4 {
 5     linklist p = (*L)->next;
 6     linklist q;
 7     int j = 0;
 8     if (i<1 || i>ListLength(L))
 9         exit(0);
10
11     while (j<i-1)  //找到第i-1个结点
12     {
13          ++j;
14          p = p->next;
15     }
16     q = p->next;  //q指向第i个结点
17    *e = q->data;
18     p->next = q->next;
19     if (q == *L)   //删除的是表尾元素，表尾指针发生改变
20         *L = p;
21     free(q);
22     return 0;
23 }

16，TravelList操作实现

 1 #include"defs.h"
 2
 3 void TravelList(linklist L)
 4 {
 5     linklist p = L->next->next;  //p指向第一个结点
 6    int j = 0;
 7
 8     while (p != L->next)  //p未到表头
 9    {
10         ++j;
11         printf("第%d个元素为：%d\n", j, p->data);
12         p = p->next;
13     }
14 }

TravelList.c

转载于:https://www.cnblogs.com/rookiefly/p/3451310.html

c语言实现--单向循环链表操作相关推荐

C语言实现单向循环链表
#include<stdio.h> #include<stdlib.h> // 单向循环链表typedef int datatype_t; typedef struct nod ...
约瑟夫环数据结构c语言程序,数据结构的C语言（类C语言）--单向循环链表--约瑟夫环...
代码区约瑟夫环:用类C语言实现!!!可以成功运行!!!不是仅仅的算法,而是实实在在的类C #include #include typedef int ElemType; typedef struct ...
单向循环链表的增、删、查、改、python实现,超详细讲解
单向循环链表的增.删.查.改具体代码如下: class Node(object):"""链表单节点实现"""def __init__(se ...
链表——单链表、单向循环链表、双向链表
目录 1 单链表节点实现单链表操作单链表实现测试链表与顺序表对比 2 单向循环链表操作实现测试 3 双向链表操作实现测试 1 单链表单向链表也叫单链表,是链表中最简单的一种形式 ...
（C语言版）链表（二）——实现单向循环链表创建、插入、删除、释放内存等简单操作
http://blog.csdn.net/fisherwan/article/details/19754585 昨天写了单向链表的代码,今天上午把单向循环链表的程序给敲完了.链表的相关操作一样的,包含 ...
c语言循环链表约瑟夫问题的时间复杂度,用单向循环链表解决约瑟夫问题算法优劣性分析.doc...
用单向循环链表解决约瑟夫问题算法优劣性分析用单向循环链表解决约瑟夫问题算法优劣性分析摘要: 首先由简单问题引入约瑟夫问题,然后用单向循环链表解决约瑟夫问题,最后对模拟方法及数学方法的优劣性进行分析 ...
从无到有算法养成篇-单向循环链表的常规操作
1.单向循环链表的创建创建 tips: 由于存在两种情况: ① 第一次开始创建; ②已经创建,往里面新增数据所以需要判断是否第一次创建链表 YES->创建一个新结点,并使得新结点的next ...
单向循环链表C语言实现
http://blog.csdn.net/morixinguan/article/details/51771633 我们都知道,单向链表最后指向为NULL,也就是为空,那单向循环链表就是不指向为NUL ...
广义表头尾链表存储结构_单向循环链表的存储结构和操作
单向循环链表的存储结构单向循环链表(Circular Linked List)是单向链表的一种扩充,当单向链表带有头结点时,把单向链表中尾结点的指针域由空指针改为头结点的指针(当单向链表不带头结点时 ...
【循环链表】数据结构——单向循环链表和双向循环链表操作笔记
循环链表一.单向循环链表 1.单向循环链表的节点 2.单向循环链表的结构二.双向循环链表 1.双向循环链表示意图 2.双向循环链表节点设计 3.双向循环链表的一般性结构 4.双向循环链表头插法插入 ...

c语言实现--单向循环链表操作

c语言实现--单向循环链表操作相关推荐

最新文章

热门文章