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

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

我学习了几天数据结构，今天下午自己写了一个单向链表的程序。我也是新手，所以刚开始学习数据结构的菜鸟们（有大牛们能屈尊看一看，也是我的荣幸）可以和我一起共同学习、讨论，当然也很高兴能指出我的错误，因为这是我们一起成长的过程。本代码包含我在写程序时的一些个人理解的说明和一些注释（如果那里说错了，望大家来指正），下面就进入正题了。

首先，这是个单向链表的代码，下面是我找的一张单向链表的示意图。


很明显可以看出它们是像链子一样串在一起，它们是靠什么串在一起的呢？可能有些人已经知道了——是指针，这里的每一个方格我们叫做“节点”，每一个节点包含一个指针指向下一个节点，并且自己被上一个节点的指针指着，然后串在一起。但是这里有一点要注意，就是头节点（就是图中的第一个节点）是不被其他节点指着的，尾节点（就是图中的最后一个节点）不指向其他的节点，程序中我们让它指向NULL，就是不指向任何东西。

SgLInkList.h   头文件

这里定义了节点的结构，包括一个数据成员和一个结构体指针，结构体指针是用来指向下一个节点用的，还包括单向链表的相关操作。

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

SgLinkList.cpp   存放单向链表相关操作函数的定义，包含链表的创建、链表值的打印、判断链表是否为空、计算链表长度、插入节点、删除节点、删除整个链表。

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include "SgLinkList.h"  

（1）第一个函数是创建单向链表，这里我首先创建了一个节点作为头节点，但是这个头节点不参与后面相关函数的运行，例如：头结点不参与链表数据的打印；只包含头节点不包含其他节点时，该链表判断为空；计算链表长度时，头结点不参与计数，删除和插入节点函数也都是从头节点后面的节点计数的。当然有一点，最后释放内存的时候，头节点是要跟着一起释放的，因为给头节点分配了内存所以也得释放，要不会造成内存泄露，这一点很容易忽视了。

[cpp] view plain copy
  1. //创建单向链表  
  2. pNODE CreateSgLinkList(void)  
  3. {  
  4.     int i, length, data;  
  5.     pNODE p_new = NULL, pTail = NULL;  
  6.     //创建头节点，头结点是第0个节点，后面的节点从1开始计数  
  7.     pNODE pHead = (pNODE)malloc(sizeof(NODE));  
  8.   
  9.     if (NULL == pHead)  
  10.     {  
  11.         printf("内存分配失败！\n");  
  12.         exit(EXIT_FAILURE);  
  13.     }  
  14.   
  15.     pHead->data = 0;  
  16.     pHead->pNext = NULL;  
  17.     pTail = pHead;  
  18.   
  19.     printf("请输入要创建链表的长度：");  
  20.     scanf("%d", &length);  
  21.   
  22.     for (i=1; i<length+1; i++)  
  23.     {  
  24.         p_new = (pNODE)malloc(sizeof(NODE));  
  25.         if (NULL == p_new)  
  26.         {  
  27.             printf("内存分配失败！\n");  
  28.             exit(EXIT_FAILURE);  
  29.         }  
  30.   
  31.         printf("请输入第%d个节点的值：", i);  
  32.         scanf("%d", &data);  
  33.   
  34.         p_new->data = data;  
  35.         p_new->pNext = NULL;  
  36.         pTail->pNext = p_new;  
  37.         pTail = p_new;  
  38.     }  
  39.     return pHead;  
  40. }  


（2）这个是打印单向链表函数，可以看到是从头结点的后面一个节点开始打印的，p=pHead->pNext。一直打印到最后一个

[cpp] view plain copy
  1. //打印单向链表，不打印头结点的值。  
  2. void TraverseSgLinkList(pNODE pHead)  
  3. {  
  4.     pNODE pt = pHead->pNext;  
  5.   
  6.     printf("打印链表：");  
  7.     while (pt != NULL)  
  8.     {  
  9.         printf("%d ", pt->data);  
  10.         pt = pt->pNext;  
  11.     }  
  12.     putchar('\n');  
  13. }  
（3）这个是判断链表是否为空的函数，通过检查头节点的后面一个节点来判断，所以这里头节点也不参与运算。
[cpp] view plain copy
  1. //判断链表是否为空  
  2. int IsEmptySgLinkList(pNODE pHead)  
  3. {  
  4.     if (pHead->pNext == NULL)  
  5.         return 1;  
  6.     else  
  7.         return 0;  
  8. }  
（4）这个是计算链表长度的函数，也是从头节点后面的节点开始，找到节点就让length加1，直到找到最后一个节点为止。
[cpp] view plain copy
  1. //计算单向链表长度  
  2. int GetLengthSgLinkList(pNODE pHead)  
  3. {  
  4.     int length = 0;  
  5.     pNODE pt = pHead->pNext;  
  6.   
  7.     while (pt != NULL)  
  8.     {  
  9.         length++;  
  10.         pt = pt->pNext;  
  11.     }  
  12.     return length;  
  13. }  

（5）这个是向单向链表插入节点的函数，这里我定义位置值是从1开始，到链表长度加1结束（当然也可以自己定义从什么数值开始），这里位置要比删除节点函数多一个，为什么呢？例如：一个链表包含三个节点（头节点除外），它们的元素值分别为1、2、3，那么我们可以插入节点的地方就有4个位置了，4个位置夹住了三个节点。但是如果是删除节点函数的话呢，操作的是实际的节点，所以位置值就只能是这三个节点了。说到这里大家应该明白了吧。这里附一张插入节点的示意图：


[cpp] view plain copy
  1. //向单向链表插入一个节点,位置从1开始，到链表长度加1结束。  
  2. int InsertEleSgLinkList(pNODE pHead, int pos, int data)  
  3. {  
  4.     pNODE pt = NULL, p_new = NULL;  
  5.   
  6.     if (pos > 0 && pos < GetLengthSgLinkList(pHead) + 2)  
  7.     {  
  8.         p_new = (pNODE)malloc(sizeof(NODE));  
  9.         if (NULL == p_new)  
  10.         {  
  11.             printf("内存分配失败！\n");  
  12.             exit(EXIT_FAILURE);  
  13.         }  
  14.         p_new->data = data;  
  15.   
  16.         while (1)  
  17.         {  
  18.             pos--;        
  19.             if (0 == pos)  
  20.                 break;  
  21.             pHead  = pHead->pNext;  
  22.         }  
  23.   
  24.         pt = pHead->pNext;  
  25.         pHead->pNext = p_new;  
  26.         p_new->pNext = pt;  
  27.   
  28.         return 1;  
  29.     }  
  30.     else  
  31.         return 0;  
  32. }  

（6）这个是删除单向链表节点的函数，至于位置值为什么是从1到链表的长度上面已经介绍过了，这里就不再介绍了。这里就说说在删除节点时要注意的地方，首先你要找到要删除的那个节点，然后把要删除节点的下一个节点的地址保存好（这里保存到pt），然后释放该节点的内存，让改指针指向NULL指针（这里因为马上要用到这个指针就没有让它指向NULL指针），接着让被删除节点的上一个的指针指向上面保存好的节点地址（也就是pt），这样节点被删除了，内存也释放了，链表也连接起来了。这就是我个人的简单理解，下面附一张示意图：


[cpp] view plain copy
  1. //从单向链表中删除一个节点，位置从1开始，到链表长度结束。  
  2. int DeleteEleSgLinkList(pNODE pHead, int pos)  
  3. {  
  4.     pNODE pt = NULL;  
  5.   
  6.     if (pos > 0 && pos < GetLengthSgLinkList(pHead) + 1)  
  7.     {  
  8.         while (1)  
  9.         {  
  10.             pos--;  
  11.             if (0 == pos)  
  12.                 break;  
  13.             pHead = pHead->pNext;  
  14.         }  
  15.   
  16.         pt = pHead->pNext->pNext;  
  17.         free(pHead->pNext);  
  18.         pHead->pNext = pt;  
  19.   
  20.         return 1;  
  21.     }  
  22.     else  
  23.         return 0;  
  24. }  

（7）这个是删除整个单向链表的函数，当然也起到了释放内存的作用。这里有两个地方要注意的就是，第一，头节点的内存也要参与释放，因为它也分配了内存；第二，这里为什么要用到指向结构体指针的指针，因为内存的分配和释放的原因，那么有人可能就要问了，为什么上面创建链表的时候没有用到这个，那是因为上面用到了返回值来获得分配的内存，这也是一种方法。

这里我就补充个知识点（可能有很多人已经知道了）：指针做函数的形参时，编译器总是要为函数的每个参数制作临时副本，指针参数p的副本是ptemp，编译器使ptemp=p。如果函数体的程序修改了ptemp的内容，就相应的就该了参数p的内容，这就是指针可以用作输出参数的原因。但是在申请内存时情况就不一样了，因为只是把ptemp所指向的内存地址改变了，但是p丝毫未变。所以，如果非要用指针参数去申请内存，那么应该用“指向指针的指针”。

[cpp] view plain copy
  1. //删除整个单向链表，释放内存。  
  2. void FreeMemory(pNODE *ppHead)  
  3. {  
  4.     pNODE pt = NULL;  
  5.     while (*ppHead != NULL)  
  6.     {  
  7.         pt = (*ppHead)->pNext;  
  8.         free(*ppHead);  
  9.         *ppHead = pt;  
  10.     }  
  11. }  

main.cpp 这是测试程序，判断函数是否得到了正确的结果。

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include "SgLinkList.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 = CreateSgLinkList();  
  12.       
  13.     flag = IsEmptySgLinkList(head);  
  14.     if (flag)  
  15.         printf("单向链表为空！\n");  
  16.     else  
  17.     {  
  18.         length = GetLengthSgLinkList(head);  
  19.         printf("单向链表的长度为：%d\n", length);  
  20.         TraverseSgLinkList(head);  
  21.     }  
  22.       
  23.     printf("请输入要插入节点的位置和元素值(两个数用空格隔开)：");  
  24.     scanf("%d %d", &position, &value);  
  25.     flag = InsertEleSgLinkList(head, position, value);  
  26.     if (flag)  
  27.     {  
  28.         printf("插入节点成功！\n");  
  29.         TraverseSgLinkList(head);  
  30.     }     
  31.     else  
  32.         printf("插入节点失败！\n");  
  33.       
  34.     flag = IsEmptySgLinkList(head);  
  35.     if (flag)  
  36.         printf("单向链表为空，不能进行删除操作！\n");  
  37.     else  
  38.     {  
  39.         printf("请输入要删除节点的位置：");  
  40.         scanf("%d", &position);  
  41.         flag = DeleteEleSgLinkList(head, position);  
  42.         if (flag)  
  43.         {  
  44.             printf("删除节点成功！\n");  
  45.             TraverseSgLinkList(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. }  

最后，我想给和我一样正在学习编程并打算把编程学好的志同道合之人一个小小的建议，光看这个代码是没有用的，还是得自己动手敲一遍，因为里面有些细节有可能你没有想到，当然你是编程神通一眼就可以看会的话那就算我多嘴了。但是我想，我们都是普通，天才还是占少数的，所以还是要动手。

希望能跟大家一起交流好的代码、好的想法，祝大家都能梦想成真！



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

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

相关文章

中断系统调用

中断系统调用

中断系统调用 系统调用可分为两类&#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 …
阅读更多...
C++ 类的深拷贝与浅拷贝||深拷贝通过重载拷贝构造函数与重载赋值运算符实现

C++ 类的深拷贝与浅拷贝||深拷贝通过重载拷贝构造函数与重载赋值运算符实现

http://blog.csdn.net/wangshihui512/article/details/9842225 在面向对象程序设计中&#xff0c;对象间的相互拷贝和赋值是经常进行的操作。 如果对象在申明的同时马上进行的初始化操作&#xff0c;则称之为拷贝运算。例如&#xff1a; class1 A("Time"); class1…
阅读更多...
C++ 类的const成员函数

C++ 类的const成员函数

http://blog.csdn.net/wangshihui512/article/details/9823739 我们定义的类的成员函数中&#xff0c;常常有一些成员函数不改变类的数据成员&#xff0c;也就是说&#xff0c;这些函数是"只读"函数&#xff0c;而有一些函数要修改类数据成员的值。如果把不改变数据…
阅读更多...
用servlet校验密码2

用servlet校验密码2

js //创建Ajax对象&#xff0c;不同浏览器有不同的创建方法&#xff0c;其实本函数就是一个简单的new语句而已。 function createXMLHttpRequest() {var XMLHttpRequest1;if (window.XMLHttpRequest) {XMLHttpRequest_test new XMLHttpRequest();} else if (window.ActiveXOb…
阅读更多...
【笔试】：编程实现C++string 类成员函数

【笔试】：编程实现C++string 类成员函数

http://blog.csdn.net/wangshihui512/article/details/9792309 已知String类声明如下&#xff1a; [cpp] view plaincopy print?class String { public: String(const char *str NULL); // 通用构造函数 String(const String &another); // 拷贝…
阅读更多...
Qt中字符串之间的转换

Qt中字符串之间的转换

//QString -> C string -> char * str.ToStdString().data(); //先转换为C的标准编码//QString -> QByteArray QString buf "123456"; QByteArray a buf.toUtf8();//中文 a buf.toLocal8Bit(); //转换为本地编码 //QByteArray -> char * char *b …
阅读更多...
最新文章

Copyright @ 2022~2023