C++实现单链表常用功能(不带头结点)

最新推荐文章于 2024-08-30 23:11:10 发布
最新推荐文章于 2024-08-30 23:11:10 发布
阅读量1.4k 收藏 2
点赞数

自己用C++实现最基本的数据结构之一单链表，常用功能都有了，可以很方便的进行栈和队列功能的扩展。另外，感谢老婆花了一个晚上帮忙测试，能够想到的场景都经过单元测试。下面是代码。

singlelist.h：链表结点数据元素类型ELEMTYPE，重载了运算符==,=,<,>，方便运算。

  1 #ifndef SINGLE_LIST_H
  2 #define SINGLE_LIST_H
  3 #include <stdlib.h>
  4 #include <stdio.h>
  5 
  6 enum
  7 {
  8     RET_SUCCESS = 0,
  9     RET_FAILURE = -1
 10 };
 11 
 12 enum
 13 {
 14     TRUE = 1,
 15     FALSE = 0
 16 };
 17 
 18 typedef struct sElemType
 19 {
 20     int m_iData;
 21     sElemType& operator= (const sElemType& elem)
 22     {
 23         if(this == &elem)
 24         {
 25          return *this;
 26         }
 27         this->m_iData = elem.m_iData;
 28         return *this;
 29     }
 30 
 31     int operator> (const sElemType& elem)
 32     {
 33         if(this->m_iData > elem.m_iData)
 34         {
 35                return TRUE;
 36         }
 37         return FALSE;
 38     }
 39 
 40     int operator< (const sElemType& elem)
 41     {
 42         if(this->m_iData < elem.m_iData)
 43         {
 44                return TRUE;
 45         }
 46         return FALSE;
 47     }
 48 
 49     int operator== (const sElemType& elem)
 50     {
 51         if(this->m_iData == elem.m_iData)
 52         {
 53             return TRUE;
 54         }
 55         return FALSE;
 56     }
 57 
 58     void print()
 59     {
 60         printf("%d",m_iData);
 61     }
 62 } ELEMTYPE;
 63 
 64 typedef struct ListNode
 65 {
 66     ELEMTYPE data;
 67     ListNode* next;
 68 } ListNode;
 69 
 70 //头部插入
 71 int insertAtHead(ListNode* &head,ELEMTYPE& elem);
 72 
 73 //尾部插入
 74 int insertAtTail(ListNode* &head,ELEMTYPE& elem);
 75 
 76 //头部删除
 77 int deleteHead(ListNode* &head,ELEMTYPE& elem);
 78 
 79 //尾部删除
 80 int deleteTail(ListNode* &head,ELEMTYPE& elem);
 81 
 82 //获取头结点元素
 83 int getHead(ListNode* &head,ELEMTYPE& elem);
 84 
 85 //获取尾结点元素
 86 int getTail(ListNode* &head,ELEMTYPE& elem);
 87 
 88 //在相等元素后插入
 89 int insertNode(ListNode* &head,ELEMTYPE& elem);
 90 
 91 //删除相应元素
 92 int deleteNode(ListNode* &head,ELEMTYPE& elem);
 93 
 94 //在相应位置插入
 95 int insertLocation(ListNode* &head,int iLocation,ELEMTYPE& elem);
 96 
 97 //删除相应位置元素
 98 int deleteLocation(ListNode* &head,int iLocation,ELEMTYPE& elem);
 99 
100 //链表长度
101 int getListLength(ListNode* &head);
102 
103 //查找元素在链表中位置
104 int search(ListNode* &head,ELEMTYPE& elem,int &iLocation);
105 
106 //逆序
107 int reverse(ListNode* &head);
108 
109 //排序
110 void sort(ListNode* &head);
111 
112 //是否空
113 int isEmpty(ListNode* &head);
114 
115 //清除所有结点
116 int clearAll(ListNode* &head);
117 
118 //打印结点信息
119 int DisplayList(ListNode* &head);
120 #endif

 

singlelist.cpp:

  1 #include "singlelist.h"
  2 
  3 int insertAtHead(ListNode* &head,ELEMTYPE& elem)
  4 {
  5     ListNode* pNode = (ListNode*)malloc(sizeof(ListNode));
  6     pNode->data = elem;
  7     if(head == NULL)
  8     {
  9         head = pNode;
 10         pNode->next = NULL;
 11         return RET_SUCCESS;
 12     }
 13     pNode->next = head;
 14     head = pNode;
 15     return RET_SUCCESS;
 16 }
 17 
 18 int insertAtTail(ListNode* &head,ELEMTYPE& elem)
 19 {
 20     ListNode* pNode = (ListNode*)malloc(sizeof(ListNode));
 21     pNode->data = elem;
 22     if(head == NULL)
 23     {
 24         head = pNode;
 25         pNode->next = NULL;
 26         return RET_SUCCESS;
 27     }
 28     ListNode* p = head;
 29     while(NULL != p->next)
 30     {
 31         p = p->next;
 32     }
 33     p->next = pNode;
 34     pNode->next = NULL;
 35     return RET_SUCCESS;
 36 }
 37 
 38 int deleteHead(ListNode* &head,ELEMTYPE& elem)
 39 {
 40     if(NULL == head)
 41     {
 42         return RET_FAILURE;
 43     }
 44     ListNode* pNode = head;
 45     head = head->next;
 46     elem = pNode->data;
 47     free(pNode);
 48     return RET_SUCCESS;
 49 }
 50 
 51 int deleteTail(ListNode* &head,ELEMTYPE& elem)
 52 {
 53     if(NULL == head)
 54     {
 55         return RET_FAILURE;
 56     }
 57     if(NULL == head->next)
 58     {
 59         elem = head->data;
 60         free(head);
 61         head = NULL;
 62         return RET_SUCCESS;
 63     }
 64     ListNode* p = head;
 65     ListNode* q = p;
 66     while(NULL != p->next)
 67     {
 68         q = p;
 69         p = p->next;
 70     }
 71     elem = p->data;
 72     q->next = NULL;
 73     free(p);
 74     return RET_SUCCESS;
 75 }
 76 
 77 int DisplayList(ListNode* &head)
 78 {
 79     if(NULL == head)
 80     {
 81         return RET_FAILURE;
 82     }
 83     ListNode* p = head;
 84     while(NULL != p)
 85     {
 86         (p->data).print();
 87         printf("-->");
 88         p = p->next;
 89     }
 90     printf("NULL");
 91     return RET_SUCCESS;
 92 }
 93 
 94 //获取头结点元素
 95 int getHead(ListNode* &head,ELEMTYPE& elem)
 96 {
 97     if(NULL == head)
 98     {
 99         return RET_FAILURE;
100     }
101     elem = head->data;
102     return RET_SUCCESS;
103 }
104 
105 //获取尾结点元素
106 int getTail(ListNode* &head,ELEMTYPE& elem)
107 {
108     if(NULL == head)
109     {
110         return RET_FAILURE;
111     }
112     ListNode* p = head;
113     while(NULL != p->next)
114     {
115         p = p->next;
116     }
117     elem = p->data;
118     return RET_SUCCESS;
119 }
120 
121 //在相等元素后插入
122 int insertNode(ListNode* &head,ELEMTYPE& elem)
123 {
124     if(NULL == head)
125     {
126         return RET_FAILURE;
127     }
128     ListNode* p = head;
129     while(NULL != p)
130     {
131         if(p->data == elem)
132         {
133             ListNode* pNode = (ListNode*)malloc(sizeof(ListNode));
134             pNode->data = elem;
135             pNode->next = p->next;
136             p->next = pNode;
137             return RET_SUCCESS;
138         }
139         p = p->next;
140     }
141     return RET_FAILURE;
142 }
143 
144 //删除相应元素
145 int deleteNode(ListNode* &head,ELEMTYPE& elem)
146 {
147     if(NULL == head)
148     {
149         return RET_FAILURE;
150     }
151     if(elem == head->data)
152     {
153         return deleteHead(head,elem); 
154     }
155     ListNode* p = head;
156     ListNode* q = p;
157     while(NULL != p)
158     {
159         if(p->data == elem)
160         {
161             q->next = p->next;
162             free(p);
163             return RET_SUCCESS;
164         }
165         q = p;
166         p = p->next;
167     }
168     return RET_FAILURE;
169 }
170 
171 //在相应位置插入
172 int insertLocation(ListNode* &head,int iLocation,ELEMTYPE& elem)
173 {
174     if(NULL == head)
175     {
176         if(iLocation != 0)
177         {
178             return RET_FAILURE;
179         }
180         else
181         {
182             return insertAtHead(head,elem);
183         }
184     }
185     if(0 == iLocation)
186     {
187         return insertAtHead(head,elem);
188     }
189     int i = 0;
190     ListNode* p = head;
191     while(NULL != p)
192     {
193         if( i == iLocation - 1)
194         {
195             ListNode* pNode = (ListNode*)malloc(sizeof(ListNode));
196             pNode->data = elem;
197             pNode->next = p->next;
198             p->next = pNode;
199             return RET_SUCCESS;
200         }
201         p = p->next;
202         i++;
203     }
204     return RET_FAILURE;
205 }
206 
207 //删除相应位置元素
208 int deleteLocation(ListNode* &head,int iLocation,ELEMTYPE& elem)
209 {
210     if(NULL == head)
211     {
212         return RET_FAILURE;
213     }
214     if(0 == iLocation)
215     {
216         return deleteHead(head,elem);
217     }
218     int i = 0;
219     ListNode* p = head;
220     ListNode* q = p;
221     while(NULL != p)
222     {
223         if(i == iLocation)
224         {
225             elem = p->data;
226             q->next = p->next;
227             free(p);
228             return RET_SUCCESS;
229         }
230         i++;
231         q = p;
232         p = p->next;
233     }
234     return RET_FAILURE;
235 }    
236 
237 //链表长度
238 int getListLength(ListNode* &head)
239 {
240     if(NULL == head)
241     {
242         return 0;
243     }
244     int i = 0;
245     ListNode* p = head;
246     while(NULL != p)
247     {
248         p= p->next;
249         i++;
250     }
251     return i;
252 }
253 
254 //查找元素在链表中位置
255 int search(ListNode* &head,ELEMTYPE& elem,int &iLocation)
256 {
257     if(NULL == head)
258     {
259         return RET_FAILURE;
260     }
261     ListNode* p = head;
262     int i = 0;
263     while(NULL != p)
264     {
265         if(p->data == elem)
266         {
267             iLocation = i;
268             return RET_SUCCESS;
269         }
270         i++;
271         p = p->next;
272     }
273     return RET_FAILURE;
274 }
275 
276 //是否空
277 int isEmpty(ListNode* &head)
278 {
279     if(NULL == head)
280     {
281         return TRUE;
282     }
283     return FALSE;
284 }
285 
286 //清除所有结点
287 int clearAll(ListNode* &head)
288 {
289     ELEMTYPE elem;
290     while(head != NULL)
291     {
292         deleteHead(head,elem);
293     }
294     return RET_SUCCESS;
295 }
296 
297 //逆序
298 int reverse(ListNode* &head)
299 {
300     if(NULL == head)
301     {
302         return RET_FAILURE;
303     }
304     if(NULL == head->next)
305     {
306         return RET_SUCCESS;
307     }
308     ListNode* p = head;
309     ListNode* q = head->next;
310     ListNode* pTemp;
311     while(q != NULL)
312     {
313         pTemp = q->next;
314         q->next = p;
315         p = q;
316         q = pTemp;
317     }
318     head->next = NULL;
319     head = p;
320     return RET_SUCCESS;
321 }
322 
323 //排序
324 void sort(ListNode* &head)
325 {
326     if(NULL == head)
327     {
328         return;
329     }
330 
331     ListNode* p = head;
332     while(NULL != p)
333     {
334         ListNode* q = head;
335         while(NULL != q->next)
336         {
337             if(q->data > q->next->data)
338             {
339                 ELEMTYPE tempElem = q->data;
340                 q->data = q->next->data;
341                 q->next->data = tempElem;
342             }
343             q = q->next;
344         }
345         p = p->next;
346     }
347 }

 


<script type="text/javascript"> </script><script type="text/javascript" src="http://pagead2.googlesyndication.com/pagead/show_ads.js"></script>
Jlins
关注
C++实现单链表：不带头结点
weixin_44915226的博客
06-17 2343
C++实现单链表：带头结点 基本功能 初始化单链表 建立单链表：头插法和尾插法 遍历单链表 按位序查找元素 按值查找元素 按位序插入结点 按位序删除结点 求单链表长度   代码 相比较带头结点的单链表，不带头结点的单链表实现部分函数时，要单独考虑第一个结点。而带头结点的单链表则不需要单独考虑。 #include <iostream> #include <stdlib.h> using namespace std; typedef int ElemType; //定
C++：带头结点的单链表基本功能实现
weixin_51121164的博客
03-21 2259
#include<iostream> using namespace std; class ListNode { public: int data; ListNode* link; ListNode(); ListNode(int item, ListNode* node); ListNode* nextNode();//return the pointer to the next node void insertAfter(ListNode* p); ListNode* rem.
c++实现 不带头结点单链表基本操作
11-24
利用c++实现不带头结点链表的基本操作实现，如逆序建立链表，插入、删除链表元素等。
C++分别创建和显示带头结点与不带头结点的单链表
03-19
最近在学数据结构，自己写的很简单的小程序，积跬步、至千里。
单链表（无头结点）（C/C++）
最新发布
a770067334的博客
08-30 801
2.带头结点的单链表，无论单链表是否为空链表，头指针都指向头结点。不带头结点的单链表，当单链表为非空链表时，头指针指向链表第一个结点(LNode)，当单链表为空链表时，头指针指向空（NULL）。1.当对单链表的表首元素进行删除或插入操作时，要进行区别处理，无头结点的单链表进行头指针的更新。38 34 12 45 43 89 6 76 此单链表的长度为：8。带头结点与不带头结点的单链表，在进行操作时有哪些区别呢？后插操作：在p结点之后插入元素e。前插操作：在P结点之前插入元素e。在第i个位置插入元素e。
C语言实现单链表（不带头结点）节点的插入
weixin_33798152的博客
08-11 314
       对单链表进行增删改查是最主要的操作。我在上一篇博客《C语言实现链表节点的删除》实现了删除单链表中的某个节点。这里我们要来实如今某个位置插入节点。演示样例代码上传至https://github.com/chenyufeng1991/InsertList  。核心代码例如以下：Node *InsertToPosition(Node *pNode,int pos,int x){ ...
基于C++的单链表实现（无头结点）
weixin_42375679的博客
11-23 1461
基于C++的不带头结点的单链表实现，主要内容包括每一个功能的分析和具体实现思路。
C/C++语言实现单链表（带头结点）
weixin_34355881的博客
02-22 480
彻底理解链表中为何使用二级指针或者一级指针的引用 数据结构之链表-链表实现及常用操作(C++篇) 　　C语言实现单链表，主要功能为空链表创建，链表初始化（头插法），链表元素读取，按位置插入，（有序链表）按值插入，按位置删除，按值删除，清空链表，销毁链表。 　　关键思路：（1）将结点创建结构体；（2）链表中添加头结点，以便统一操作；（3）使用结点一级指针和二级指针的异同点；（4）链表的...
单链表的实现（带头结点/不带头结点）
SherlockAdele_qc的博客
04-25 837
带头结点 #include<stdio.h> #include<stdlib.h> #include<iostream> using namespace std; //单链表结点的定义 typedef struct LNode{ int data; struct LNode *next; }LNode,*LinkedList; //单链表的初始化 bool InitList(LinkedList &L){ L=(LNode *)malloc(.
C++ - 链式实现Josephus问题(不带头节点的单链表)
biaogexf
03-24 820
Josephus问题描述 ：     设有n个人围坐在一个圆桌周围，现从第s个人开始报数，数到第m的人出列、然后从出列的下一个人开始重新报数，数到第m的人又出列，如此反复直到所有人全部出列为止。要求：对于任意给定的n、s、m，求出按出列次序得到的n个人员的序列。/* 上机题1 - 单链表实现Josephus问题 */ #include &lt;iostream&gt; #include &lt;m...
数据结构：不带头结点单链表的实现及其一些基本操作.cpp
08-03
不带头结点，不带头结点，不带头结点！ 实现单链表及其一些基本操作函数（不带头结点） 1.头文件包含 2.宏定义及节点类型描述 3.初始化、判断是否为空 4.指定位置插入操作 5.在p节点后插入元素e 6.在p节点前插入元素e 7.删除操作：删除第i个节点，元素值有e传回 8.删除指定节点，不能删除尾部节点 9.按位序查找和按值查找 10.尾插法和头插法建立单链表（包含初始化） 11.表长和简单打印 12.其他简单封装（_fz表示封装） main函数简单测试
单链表的实现(不带头结点)
07-18 6637
vs2008运行正确，如有误，请各位大牛指正！ 实验证明：在某些情况下(比如拷贝构造函数，尾插法建表)，不带头结点的单链表需要单独处理第一个元素。引入头结点的好处在于表中的每个元素的处理可以统一。                强烈推荐使用带头结点的单链表。 // LinkList.cpp : 定义控制台应用程序的入口点。 //定义的链表不含头结点 #include "stdafx.
数据结构C/C++语言-基于数组创建不带头结点的单链表头插法/尾插法创建
JJ9845324的博客
09-23 515
以数组创建不带头结点的单链表 直接利用数组实现的思想 ```c++ LinkList L; int a[10] = {1, 2, 4, 5, 6, 74, 6, 5, 8, 5,}; int i = 0; L = (LinkList) malloc(sizeof(LNode)); LNode *s; LNode *r = L; L->data = a[0]; for (i = 1; i < 10; i++) { s = (LinkList) malloc(sizeof(LNode));
实现不带头结点的单链表
哥不帅但很坏的博客
03-23 1097
链表：链表是一种线性表，但不是顺序存储，而是每个节点里面存储者下一个节点的指针，把存储数据元素的数据串链起来。 不带头结点的链表也可以分为三种： 我们的代码实现的是第二种： #define _CRT_SECURE_NO_WARNINGS 1 #include #include using namespace std; //不带头结点的链表(含有指向头结点和尾节点的指
不带头节点的单链表
xuruhua的博客
05-23 2705
.h# pragma once # include&lt;stdio.h&gt; # include&lt;stdlib.h&gt; # include&lt;string.h&gt; # include&lt;assert.h&gt; typedef int DataType; typedef struct Node { struct Node* _pNext; DataType _da...
数据结构笔记15：C/C++中创建(带头结点、不带头结点的)单链表（图解版）
亦木的博客
04-29 2179
1.尾插法建立带头结点的单链表 尾插法思想 尾插法的思想其实很简单，通俗来讲就是每创建一个新节点都插到原来链表的后面。 代码实现 Node *Head, *L, *LNew; /* 申请节点 */ Head = (Node *)malloc(sizeof(Node)); /* 带头结点 */ L = Head; L->next = NULL; /* 初始赋值 */ for(int ...
不带头结点的单链表代码实现
天空的博客
10-20 2717
不带头结点的单链表代码实现
C/C++中创建(带头结点、不带头结点的)单链表（图解版）
qq_41624560的博客
05-29 904
https://blog.csdn.net/weixin_43193864/article/details/105846546
C++实现的带头结点单链表操作全解析：增删改查
本文档详细介绍了如何使用C++实现带头结点的单链表操作，涵盖了单链表在数据结构中的关键功能。作者MadeByFred韩提供了丰富的链表操作方法，包括但不限于： 1. **节点添加**: - `bool addNode()`：预设三个节点并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值