（C语言版）链表（二）——实现单向循环链表创建、插入、删除、释放内存等简单操作

http://blog.csdn.net/fisherwan/article/details/19754585

昨天写了单向链表的代码，今天上午把单向循环链表的程序给敲完了。链表的相关操作一样的，包含链表的创建、判断链表是否为空、计算链表长度、向链表中插入节点、从链表中删除节点、删除整个链表释放内存。如果单向链表理解了，那单向循环链表也就不难了。

单向循环链表如下图所示：


看图可以知道，单向循环链表和单向链表差不多，只不过是最后的尾节点指向的不是空，而是指向头节点。理解这一点很重要，因为这是我们写程序的关键。下面我们上代码：

SqCcLinkList.h 头文件——定义了节点结构体，以及相关操作的函数声明。

[cpp] view plain copy
  1. #ifndef ONE_WAY_CIRCULAR_LINK_LIST_H  
  2. #define ONE_WAY_CIRCULAR_LINK_LIST_H  
  3.   
  4. typedef struct Node  
  5. {  
  6.     int data;  
  7.     struct Node *pNext;  
  8. }NODE, *pNODE;  
  9.   
  10. //创建单向循环链表  
  11. pNODE CreateSgCcLinkList(void);  
  12.   
  13. //打印链表  
  14. void TraverseSgCcLinkList(pNODE pHead);  
  15.   
  16. //判断链表是否为空  
  17. int IsEmptySgCcLinkList(pNODE pHead);  
  18.   
  19. //计算链表的长度  
  20. int GetLengthSgCcLinkList(pNODE pHead);  
  21.   
  22. //向链表中插入节点  
  23. int InsertEleSgCcLinkList(pNODE pHead, int pos, int data);  
  24.   
  25. //从链表中删除节点  
  26. int DeleteEleSgCcLinkList(pNODE pHead, int pos);  
  27.   
  28. //删除整个链表，释放内存  
  29. void FreeMemory(pNODE *ppHead);  
  30.   
  31. #endif  


SqCcLinkList.cpp 链表源文件——这里包含了各种相关操作的函数的定义。

（1）这部分是创建链表，和单向链表一样，一开始也是创建了一个头节点，初始化时，头结点的指针指向自己（这是和单向链表不一样的地方）。在写程序时，主要体现在下面的一行代码：

[cpp] view plain copy
  1. p_new->pNext = pHead;    //这里一定是pHead，因为最后一个节点总是指着头节点  
它的意思就是没创建一个节点，让这个节点指向头节点，然后就形成了一个环，也就成了循环链表。

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include "SgCcLinkLIst.h"  
  4.   
  5. //创建单向循环链表  
  6. pNODE CreateSgCcLinkList(void)  
  7. {  
  8.     int i, length = 0, data = 0;  
  9.     pNODE pTail = NULL, p_new = NULL;  
  10.     pNODE pHead = (pNODE)malloc(sizeof(NODE));  
  11.   
  12.     if (NULL == pHead)  
  13.     {  
  14.         printf("内存分配失败！\n");  
  15.         exit(EXIT_FAILURE);  
  16.     }  
  17.       
  18.     pHead->data = 0;  
  19.     pHead->pNext = pHead;  
  20.     pTail = pHead;  
  21.   
  22.     printf("请输入要创建链表的长度：");  
  23.     scanf("%d", &length);  
  24.   
  25.     for (i=1; i<length+1; i++)  
  26.     {  
  27.         p_new = (pNODE)malloc(sizeof(NODE));  
  28.   
  29.         if (NULL == p_new)  
  30.         {  
  31.             printf("内存分配失败！\n");  
  32.             exit(EXIT_FAILURE);  
  33.         }  
  34.   
  35.         printf("请输入第%d个节点的元素值：", i);  
  36.         scanf("%d", &data);  
  37.   
  38.         p_new->data = data;  
  39.         p_new->pNext = pHead;    //这里一定是pHead，因为最后一个节点总是指着头节点  
  40.         pTail->pNext = p_new;  
  41.         pTail = p_new;  
  42.     }  
  43.   
  44.     return pHead;  
  45. }  
（2）这部分是获得链表的相关信息，和单向链表一样，头节点不参与运算；但是和单向链表不同的地方就是判断的时候是和头结点进行比较，如何相等的话呢，说明到了链表的结尾。

[cpp] view plain copy
  1. //打印链表  
  2. void TraverseSgCcLinkList(pNODE pHead)  
  3. {  
  4.     pNODE pt = pHead->pNext;  
  5.   
  6.     printf("链表打印如：");  
  7.     while (pt != pHead)  
  8.     {  
  9.         printf("%d ", pt->data);  
  10.         pt = pt->pNext;  
  11.     }  
  12.     putchar('\n');  
  13. }  
  14.   
  15. //判断链表是否为空  
  16. int IsEmptySgCcLinkList(pNODE pHead)  
  17. {  
  18.     if (pHead->pNext == pHead)  
  19.         return 1;  
  20.     else  
  21.         return 0;  
  22. }  
  23.   
  24. //计算链表长度  
  25. int GetLengthSgCcLinkList(pNODE pHead)  
  26. {  
  27.     int length = 0;  
  28.     pNODE pt = pHead->pNext;  
  29.   
  30.     while (pt != pHead)  
  31.     {  
  32.         length++;  
  33.         pt = pt->pNext;  
  34.     }  
  35.     return length;  
  36. }  

（3）这部分是链表的插入和删除操作，和单向链表一样。

[cpp] view plain copy
  1. //向链表中插入节点  
  2. int InsertEleSgCcLinkList(pNODE pHead, int pos, int data)  
  3. {  
  4.     pNODE p_new = NULL;  
  5.   
  6.     if (pos > 0 && pos < GetLengthSgCcLinkList(pHead) + 2)  
  7.     {  
  8.         p_new = (pNODE)malloc(sizeof(NODE));  
  9.   
  10.         if (NULL == <span style="font-family: Arial, Helvetica, sans-serif;">p_new </span><span style="font-family: Arial, Helvetica, sans-serif;">)</span>  
  11.         {  
  12.             printf("内存分配失败！\n");  
  13.             exit(EXIT_FAILURE);  
  14.         }  
  15.   
  16.         while (1)  
  17.         {  
  18.             pos--;  
  19.             if (0 == pos)  
  20.                 break;  
  21.             pHead = pHead->pNext;  
  22.         }  
  23.           
  24.         p_new->data = data;  
  25.         p_new->pNext = pHead->pNext;  
  26.         pHead->pNext = p_new;  
  27.   
  28.         return 1;  
  29.     }  
  30.     else  
  31.         return 0;  
  32. }  
[cpp] view plain copy
  1. <span style="font-family: Arial, Helvetica, sans-serif;">//从链表中删除节点</span>  
[cpp] view plain copy
  1. int DeleteEleSgCcLinkList(pNODE pHead, int pos)  
  2. {  
  3.     pNODE pt = NULL;  
  4.   
  5.     if (pos > 0 && pos < GetLengthSgCcLinkList(pHead) + 1)  
  6.     {  
  7.         while (1)  
  8.         {  
  9.             pos--;  
  10.             if (0 == pos)  
  11.                 break;  
  12.             pHead = pHead->pNext;  
  13.         }  
  14.   
  15.         pt = pHead->pNext->pNext;  
  16.         free(pHead->pNext);  
  17.         pHead->pNext = pt;  
  18.   
  19.         return 1;  
  20.     }  
  21.     else  
  22.         return 0;  
  23. }  
（4）这部分是释放内存，和单向链表有些不一样，因为单向循环链表是个环，最后只剩下头节点的时候要单独处理，这个受我判断条件的限制。当然可能有更好的方法，我们可以共同讨论。这里我分了两种情况来释放内存。
[cpp] view plain copy
  1. //删除整个链表，释放内存  
  2. void FreeMemory(pNODE *ppHead)  
  3. {  
  4.     pNODE pt = NULL;  
  5.   
  6.     while (*ppHead != NULL)  
  7.     {  
  8.         if (*ppHead == (*ppHead)->pNext) //如果只有头节点一个  
  9.         {  
  10.             free(*ppHead);  
  11.             *ppHead = NULL;  
  12.         }  
  13.         else                    //如果不止头节点一个  
  14.         {  
  15.             pt = (*ppHead)->pNext->pNext;  
  16.             free((*ppHead)->pNext);  
  17.             (*ppHead)->pNext = pt;  
  18.         }  
  19.     }  
  20. }  


main.cpp 测试程序源文件——这个程序通过一些简单的交互用来测试各个函数是否实现了各自的功能。

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include "SgCcLinkList.h"  
  4.   
  5. int main(void)  
  6. {  
  7.     int flag = 0, length = 0;  
  8.     int position = 0, value = 0;  
  9.     pNODE head = NULL;  
  10.   
  11.     head = CreateSgCcLinkList();  
  12.   
  13.     flag = IsEmptySgCcLinkList(head);  
  14.     if (flag)  
  15.         printf("单向循环链表为空！\n");  
  16.     else  
  17.     {  
  18.         length = GetLengthSgCcLinkList(head);  
  19.         printf("单向循环链表的长度为：%d\n", length);  
  20.         TraverseSgCcLinkList(head);  
  21.     }  
  22.   
  23.     printf("请输入要插入节点的位置和元素值(两个数用空格隔开)：");  
  24.     scanf("%d %d", &position, &value);  
  25.     flag = InsertEleSgCcLinkList(head, position, value);  
  26.     if (flag)  
  27.     {  
  28.         printf("插入节点成功！\n");  
  29.         TraverseSgCcLinkList(head);  
  30.     }     
  31.     else  
  32.         printf("插入节点失败！\n");  
  33.   
  34.     flag = IsEmptySgCcLinkList(head);  
  35.     if (flag)  
  36.         printf("单向循环链表为空，不能进行删除操作！\n");  
  37.     else  
  38.     {  
  39.         printf("请输入要删除节点的位置：");  
  40.         scanf("%d", &position);  
  41.         flag = DeleteEleSgCcLinkList(head, position);  
  42.         if (flag)  
  43.         {  
  44.             printf("删除节点成功！\n");  
  45.             TraverseSgCcLinkList(head);  
  46.         }     
  47.         else  
  48.             printf("删除节点失败！\n");  
  49.     }  
  50.   
  51.     FreeMemory(&head);  
  52.     if (NULL == head)  
  53.         printf("已成功删除单向循环链表，释放内存完成！\n");  
  54.     else  
  55.         printf("删除单向循环链表失败，释放内存未完成！\n");  
  56.   
  57.     return 0;  
  58. }  
PS：数据结构的学习还在继续，刚开始写这个程序的时候，在释放内存的时候碰到了一些问题，不过后面通过调试还是解决了。所以，我想说调试能力也是很重要的，因为调试过一篇，你对这个程序的原理也懂的差不多了。如果你们在看程序的时候发现错误，希望能积极指出来。

下一站是双向链表。加油吧！


本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/384265.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

计科院首页静态网页

计科院首页静态网页

一.HTML代码 <!DOCTYPE html><html><head><meta charset"UTF-8"><title>首页</title> </head><body><div id"page"> <div id"page_head"> <div id"logo" aligncenter…
阅读更多...
可重入函数

可重入函数

一个函数在被调用执行期间(尚未调用结束)&#xff0c;由于某种时序又被重复调用&#xff0c;称之为“重入”。根据函数实现的方法可分为“可重入函数”和“不可重入函数”两种。 注意事项 定义可重入函数&#xff0c;函数内不能含有全局变量及static变量&#xff0c;不能使用ma…
阅读更多...
（C语言版）链表（四）——实现双向循环链表创建、插入、删除、释放内存等简单操作

（C语言版）链表（四）——实现双向循环链表创建、插入、删除、释放内存等简单操作

http://blog.csdn.net/fisherwan/article/details/19801993 双向循环链表是基于双向链表的基础上实现的&#xff0c;和双向链表的操作差不多&#xff0c;唯一的区别就是它是个循环的链表&#xff0c;通过每个节点的两个指针把它们扣在一起组成一个环状。所以呢&#xff0c;每个…
阅读更多...
SIGCHLD

SIGCHLD

SIGCHLD的产生条件 子进程终止时 子进程接收到SIGSTOP信号停止时 子进程处在停止态&#xff0c;接受到SIGCONT后唤醒时 借助SIGCHLD信号回收子进程 子进程结束运行&#xff0c;其父进程会收到SIGCHLD信号。该信号的默认处理动作是忽略。可以捕捉该信号&#xff0c;在捕捉函数中…
阅读更多...
（C语言版）链表（一）——实现单向链表创建、插入、删除等简单操作（包含个人理解说明及注释，新手跟着写代码）

（C语言版）链表（一）——实现单向链表创建、插入、删除等简单操作（包含个人理解说明及注释，新手跟着写代码）

http://blog.csdn.net/fisherwan/article/details/19701027 我学习了几天数据结构&#xff0c;今天下午自己写了一个单向链表的程序。我也是新手&#xff0c;所以刚开始学习数据结构的菜鸟们&#xff08;有大牛们能屈尊看一看&#xff0c;也是我的荣幸&#xff09;可以和我一起…
阅读更多...
中断系统调用

中断系统调用

中断系统调用 系统调用可分为两类&#xff1a;慢速系统调用和其他系统调用。 慢速系统调用&#xff1a;可能会使进程永远阻塞的一类。如果在阻塞期间收到一个信号&#xff0c;该系统调用就被中断,不再继续执行(早期)&#xff1b;也可以设定系统调用是否重启。如&#xff0c;rea…
阅读更多...
（C++版）链表（二）——实现单项循环链表创建、插入、删除等操作

（C++版）链表（二）——实现单项循环链表创建、插入、删除等操作

http://blog.csdn.net/fisherwan/article/details/25561857 链表&#xff08;二&#xff09;单向循环链表的实现&#xff0c;下面实现代码&#xff1a; [cpp] view plaincopy <span style"font-size:18px;" deep"5">#include <iostream> #in…
阅读更多...
会话

会话

创建会话 创建一个会话需要注意以下6点注意事项&#xff1a; 调用进程不能是进程组组长&#xff0c;该进程变成新会话首进程(session header)该进程成为一个新进程组的组长进程。需有root权限(ubuntu不需要)新会话丢弃原有的控制终端&#xff0c;该会话没有控制终端该调用进程是…
阅读更多...
守护进程

守护进程

守护进程 Daemon(精灵)进程&#xff0c;是Linux中的后台服务进程&#xff0c;通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。一般采用以d结尾的名字。 Linux后台的一些系统服务进程&#xff0c;没有控制终端&#xff0c;不能直接和用户交互。不受用户登…
阅读更多...
（C++版）链表（三）——实现双向链表的创建、插入、删除等简单操作

（C++版）链表（三）——实现双向链表的创建、插入、删除等简单操作

http://blog.csdn.net/fisherwan/article/details/25649073 链表&#xff08;三&#xff09;实现双向链表操作&#xff0c;代码如下&#xff1a; [cpp] view plaincopy <span style"font-size:18px;" deep"5">#include <iostream> #include …
阅读更多...
（C++版）链表（四）——实现双向循环链表创建、插入、删除等简单操作

（C++版）链表（四）——实现双向循环链表创建、插入、删除等简单操作

http://blog.csdn.net/fisherwan/article/details/25649271 链表&#xff08;四&#xff09;实现双向循环链表简单操作&#xff0c;代码如下&#xff1a; [cpp] view plaincopy <span style"font-size:18px;" deep"5">#include <iostream> #…
阅读更多...
java web开发环境搭建

java web开发环境搭建

1.安装并配置JDK环境&#xff08;1&#xff09;安装过程省略&#xff08;建议安装在自己指定的统一目录下&#xff0c;方便后期查找&#xff09;。 &#xff08;2&#xff09;配置环境变量 JAVA_HOME: C:\Java\jdk\jdk1.7.0_45 &#xff08;jdk安装目录路径&#xff09; Path:…
阅读更多...
java script简介

java script简介

一.JavaScript介绍&#xff08;摘抄于百度百科&#xff09; JavaScript一种直译式脚本语言&#xff0c;是一种动态类型、弱类型、基于原型的语言&#xff0c;内置支持类型。它的解释器被称为JavaScript引擎&#xff0c;为浏览器的一部分&#xff0c;广泛用于客户端的脚本语言&a…
阅读更多...
双向链表的创建和相关操作

双向链表的创建和相关操作

http://blog.csdn.net/jw903/article/details/38947753 双向链表其实是单链表的改进。 当我们对单链表进行操作时&#xff0c;有时你要对某个结点的直接前驱进行操作时&#xff0c;又必须从表头开始查找。这是由单链表结点的结构所限制的。因为单链表每个结点只有一个存储直接后…
阅读更多...
链表各类操作详解

链表各类操作详解

http://blog.csdn.net/hackbuteer1/article/details/6591486/ 链表概述 　　 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量&#xff0c;以head表示&#xff0c;它存放一个地址。该地址指向一个元…
阅读更多...
信号和槽

信号和槽

信号槽是 Qt 框架引以为豪的机制之一。所谓信号槽&#xff0c;实际就是观察者模式。当某个事件发生之后&#xff0c;比如&#xff0c;按钮检测到自己被点击了一下&#xff0c;它就会发出一个信号&#xff08;signal&#xff09;。这种发出是没有目的的&#xff0c;类似广播。如…
阅读更多...
登陆界面

登陆界面

界面展示&#xff1a; <!DOCTYPE html> <html><head><meta charset"utf-8"><title>电子邮件登录</title><link href"style.css" type"text/css" rel"stylesheet"></head><body>…
阅读更多...
C语言实现双向链表删除、插入、双向输出

C语言实现双向链表删除、插入、双向输出

http://www.cnblogs.com/dyllove98/archive/2013/07/31/3228857.html #include<cstdio> #include<cstdlib> typedef struct DoubleLinkedList {int data;struct DoubleLinkedList *pre;struct DoubleLinkedList *next; }DlinkedList_Node; //建立链表 DlinkedList_…
阅读更多...
servlet概述

servlet概述

一、什么是Servlet呢&#xff1f; servlet 是由sun公司提供的动态web资源开发技术&#xff0c;本质上就是一段Java程序&#xff0c;这段java程序无法独立运行&#xff0c;必须放在Servlet容器&#xff08;比如&#xff1a;tomcat服务器&#xff09;中运行&#xff0c;由容器调用…
阅读更多...
运用递归将两个链表进行连接

运用递归将两个链表进行连接

http://blog.csdn.net/zjut_ym/article/details/45008259 建立2个数据项按从大到小排列的链表&#xff0c;实现2个链表的合并&#xff0c;并输出合并后链表的数据项。 函数代码如下 #include<iostream> using namespace std; struct node{int data;node *next; }; node …
阅读更多...
最新文章

Copyright @ 2022~2023