C++实现无头结点单链表

已于 2022-05-26 14:52:29 修改
阅读量1.1k 收藏 3
点赞数
分类专栏： 数据结构 文章标签： c++ 开发语言 数据结构
于 2022-05-23 11:46:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/i777777777777777/article/details/124924506
版权

C++实现单链表

SList.h


#include<iostream>
#include<assert.h>
using namespace std;

typedef int DataType;

struct Node
{
	DataType data;
	struct Node* next;
};

class SList
{
public:
	SList() :head(nullptr) {}
	SList(const SList& sl) { head = copySList(sl); }
	SList& operator=(const SList& sl)
	{
		Node* p = copySList(sl);
		free();
		head = p;
		return *this;
	}
	~SList() { free(); }
public:
	void push_back(const DataType&);
	void push_front(const DataType&);
	void pop_back();
	void pop_front();
	void print()const;
	Node* find(const DataType&);   // 以某值为索引，查找某节点
	void insert(Node* p, const DataType&);  // 在p结点之后插入一个值
	void erase(Node* p);   // 删除p结点
private:
	Node* head;
	void free()
	{
		while (head != nullptr)
		{
			Node* next = head->next;
			delete head;
			head = next;
		}
		head = nullptr;
	}
	Node* copySList(const SList& sl)
	{
		//SList newsl;
		//Node* cur = sl.head;
		//while (cur != NULL)
		//{
		//	newsl.push_back(cur->data);
		//	cur = cur->next;
		//}
		//return newsl.head;
		Node ret{ 0,NULL };
		Node* node = &ret;
		Node* cur = sl.head;
		while (cur != NULL)
		{
			Node* tmp = new Node{ cur->data,NULL };
			node->next = tmp;
			node = node->next;
			cur = cur->next;
		}
		return ret.next;
	}
	Node* CreatNode(const DataType& x)
	{
		Node* newnode = new Node{ x, nullptr };
		//newnode->data = x;
		//newnode->next = nullptr;
		return newnode;
	}
};

SList.cpp

#include"SList.h"

void SList::push_back(const DataType& x)
{
	Node* newnode = CreatNode(x);
	if (head == nullptr)
	{
		head = newnode;
		return;
	}
	Node* cur = head;
	while (cur->next != nullptr)
	{
		cur = cur->next;
	}
	cur->next = newnode;
}

void SList::push_front(const DataType& x)
{
	Node* newnode = CreatNode(x);
	newnode->next = head;
	head = newnode;
}


void SList::pop_back()
{
	assert(head);
	if (head->next == nullptr)
	{
		delete head;
		head = nullptr;
	}
	else
	{
		Node* cur = head;
		while (cur->next->next != nullptr)
		{
			cur = cur->next;
		}
		delete cur->next;
		cur->next = nullptr;
	}
}

void SList::pop_front()
{
	Node* tmp = head;
	head = head->next;
	delete tmp;
}

void SList::print()const
{
	if (head == nullptr)
		cout << "null" << endl;
	else
	{
		Node* cur = head;
		while (cur != nullptr)
		{
			cout << cur->data << " -> ";
			cur = cur->next;
		}
		cout << "null" << endl;
	}
}

Node* SList::find(const DataType& x)   // 以某值为索引，查找某节点
{
	assert(head);
	Node* cur = head;
	while (cur != nullptr)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return nullptr;
}

void SList::insert(Node* p, const DataType& x)
{
	Node* newnode = CreatNode(x);
	assert(p);
	newnode->next = p->next;
	p->next = newnode;
}

void SList::erase(Node* p)
{
	assert(p);
	if (head == p)
	{
		Node* tmp = head->next;
		delete head;
		head = tmp;
	}
	{
		Node* cur = head;
		while (cur->next != p)
		{
			cur = cur->next;
		}
		cur->next = cur->next->next;
		delete p;
	}
}

测试




void test()
{
	SList sl1;
	sl1.push_back(1);
	sl1.push_back(2);
	sl1.push_back(3);
	sl1.push_back(4);
	sl1.push_back(5);
	sl1.push_front(6);
	sl1.push_front(7);
	sl1.push_front(8);
	sl1.print();
	sl1.pop_back();
	sl1.pop_front();
	sl1.print();
	sl1.insert(sl1.find(6), 66);
	sl1.print();
	sl1.erase(sl1.find(6));
	sl1.print();
	SList sl2(sl1);
	sl2.push_back(88);
	sl2.print();
	sl1.print();
	sl1 = sl2;
	sl1.print();
}


int main()
{
	test();
	return 0;
}

代码评价：

比较好的是私有成员函数copySList的建立，可以辅助建立拷贝构造函数和拷贝赋值运算符。

作用就是再拷贝一份相同的链表，并返回新建链表的头结点，需要自定义拷贝成员的原因是链表的建立需要开辟动态内存，且是类值的，不能进行浅拷贝和默认析构。 

因为此单链表无头结点，所以在尾插尾删等处需要分情况进行讨论。

单链表：

单链表相比于顺序表并没有明显的进步：单链表头插头删效率高，但是尾插尾删仍是O(N)，且中间元素的删除插入也是O(N)，并且不支持顺序表的随机访问。

一个小的进步就是单链表按需存储释放空间。 

无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结 构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

 

顺便给出C语言实现的单链表

SList.h

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SListDataType;   //typedef需要分号结尾

typedef struct SListNode
{
	SListDataType data;       //数据
	struct SListNode* next; //下一个节点的地址
}SListNode;

// 创建一个节点
SListNode* CreatSLTNode(SListDataType x);
// 打印一个链表，传入头节点，因为不会更改，所以传一维指针即可。
void PrintSList(SListNode* pnode);
// 尾插
void SListPushBack(SListNode** pphead, SListDataType x);
// 头插
void SListPushFront(SListNode** pphead, SListDataType x);
// 尾删
void SListPopBack(SListNode** pphead);
// 头删
void SListPopFront(SListNode** pphead);
// 查找某节点
SListNode* SListFind(SListNode* phead, SListDataType x);
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SListDataType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos);
//链表的销毁
void SListDestroy(SListNode** phead);

SList.c 

#include"SList.h"  //单链表

SListNode* CreatSLTNode(SListDataType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	assert(newnode);
	newnode->data = x;
	newnode->next = NULL;
	return newnode;  //newnode是那个新的节点的地址，内容已经初始化，next为NULL。
}

void PrintSList(SListNode* phead)
{
	SListNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

void SListPushBack(SListNode** phead, SListDataType x)   //phead是头节点地址的地址，*phead即那个节点的指针。
{
	SListNode* newnode = CreatSLTNode(x);
	if (*phead == NULL)
		*phead = newnode;
	else
	{
		SListNode* cur = *phead;
		while (cur->next != NULL)
		{
			cur = cur->next;
		}
		(*cur).next = newnode;
		//cur->next = newnode;
	}
}

void SListPushFront(SListNode** pphead, SListDataType x)
{
	SListNode* newnode = CreatSLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;  //一维指针的地址进行解引用。
}

void SListPopBack(SListNode** pphead)
{
	//尾删
	assert(*pphead);  //防止这是一个空链表
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SListNode* cur = *pphead;
		while (cur->next->next != NULL)
		{
			cur = cur->next;
		}
		free(cur->next);
		cur->next = NULL;
		//SLTNode* tail = *pphead;
		//SLTNode* Pretail = NULL;
		//while (tail->next != NULL)
		//{
		//	Pretail = tail;
		//	tail = tail->next;
		//}
		//free(tail);
		//Pretail->next = NULL;
	}
}

void SListPopFront(SListNode** pphead)
{
	assert(*pphead);  //断言头节点的指针不为空

	//SListNode* tmp = (*pphead)->next;
	//free(*pphead);
	//*pphead = tmp;
	SListNode* tmp = *pphead;
	*pphead = (*pphead)->next;
	free(tmp);
}

SListNode* SListFind(SListNode* phead, SListDataType x)
{
	assert(phead);  //如果这个结构体指针为空，表明这是一个空链表。
	SListNode* cur = phead;//则这个结构体指针不为空，只少有一个节点。
	while (cur)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

void SListInsertAfter(SListNode* pos, SListDataType x)
{
	assert(pos);
	SListNode* newnode = CreatSLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	if(!pos->next)  //如果这个是最后一个节点，什么也不做
	{
		return;
	}
	else
	{
		SListNode* tmp = pos->next;
		pos->next = pos->next->next;
		free(tmp);
		tmp = NULL;
	}
}

void SListDestroy(SListNode** phead)
{
	assert(*phead); //
	SListNode* cur = *phead, *next = (*phead)->next;
	while (cur)
	{
		next = cur->next;
		free(cur);
		cur = next;
	}
	*phead = NULL;
}

作用可能就是可以加深对指针的理解吧。需要修改结构体，则需要传指向结构体的指针，需要修改一级指针，则需要传指向一级指针的指针：即二级指针。因为此单链表无头结点，所以若空链表情况下进行尾插，则需要修改指向链表第一个结点的指针，所以头插尾插头删尾删需要传二级指针。

__zz11
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
无头结点链表实现
12-01
用C++简单实现无头结点的建表，插入，删除操作
【数据结构与算法】 - (不带头结点)单链表详细实现思路及代码(C/C++语言)
wkd_007的博客
03-26 5002
文章先介绍 “头结点” 在链表的作用，以及 “有头结点” 和 “无头结点” 的区别，然后再详细介绍了“无头结点链表” 的实现步骤，最后给出了 “无头结点单链表” 的C语言实现代码，同时也给出了 “有头结点单链表” 的C语言实现代码。读者可以对比这两份代码，将会对单链表的“头结点”有非常深刻的理解。
链表基础1——无头结点单向非循环链表的基本操作（c语言实现）
最新发布
2301_80224556的博客
04-14 882
二，尾部插入一个元素。
【数据结构初阶】链表（上）——无头单向非循环链表的实现
m0_70811813的博客
11-02 392
链表、无头单向非循环链表的实现、无头单向非循环链表实现完整代码、运行测试
数据结构无头结点单向不循环链表（C语言版）
qq_45767476的博客
04-29 194
main.c(负责测试） #include <stdlib.h> #include <stdio.h> #include <time.h> #include "nohead.h" int main() { LNode *list = NULL; struct score_st data[10],mydata,data1; int i = 0; srand((unsigned)time(NULL)); //初始化数组 for (i = 0; i < 10;
单链表（无头结点）（C/C++）
沉默安的博客
08-04 1090
带头结点与不带头结点的单链表，在进行操作时有哪些区别呢？ 当对单链表的表首元素进行删除或插入操作时，要进行区别处理，无头结点的单链表进行头指针的更新。 带头结点的单链表，无论单链表是否为空链表，头指针都指向头结点。不带头结点的单链表，当单链表为非空链表时，头指针指向链表第一个结点(LNode)，当单链表为空链表时，头指针指向空（NULL）。 //不带头结点的链表 #include<stdio.h> #include<stdlib.h> typedef int Elemtype;
数据结构基础-C/C++实现单链表（无头结点）
qq_42908756的博客
04-11 1517
定义一个结构体 /** * @brief 链表节点 */ typedef struct LinkedNode{ // 存储数据 int data; // 下一个节点的地址 LinkedNode *next; }LinkedNode, *LinkedList; 初始化 /** * @brief 初始化一个不带头结点的单链表 * * @return LinkedList NULL */ LinkedList initLinkedListNoHead() { // 因为.
【数据结构】-单链表(无头结点）
RunningSnail的博客
07-18 4018
单链表-无头结点1.头文件及类型定义2.单链表结点类型定义3.函数声明4.基本操作4.1 初始化单链表4.2 判空4.3 插入操作4.3.1 按位插入4.3.2 指定结点插入4.3.2.1 指定结点后插4.3.2.2 指定结点前插4.3.2.2.1 前插法1(时间复杂度为O(n))4.3.2.2.2 前插法2(时间复杂的为O(1))4.4 删除操作4.4.1 按位删除4.4.2 指定结点删除4.4.2.1 删除法1(时间复杂度为O(n))4.4.2.2 删除法2(时间复杂度为O(1))4.5 查找操作4.5
用C++实现一个单链表
04-15
已在win10和macOS双平台调试通过！支持单链表的基本操作，遍历，头插法尾插法，删除，修改操作。
无头节点的单链表
07-17
无头节点单链表的实现可是说是对C语言指针一个最直接、最贴合实际、也是最具有归纳性的程序设计应用。许多C语言基础面试题都涉及单链表的实现和构造，其目的就是考察面试者对C语言基础数据类型是否有足够的了解，对...
C++使用模板实现单链表
12-31
本文实例为大家分享了用模板实现单链表，供大家参考，具体内容如下 话不多说 直接上代码 #include using namespace std; template class CLink; template class Node { friend class CLink; public: /* 构造...
【不带头节点的单链表】
98同学吖的博客
04-23 2503
不带头节点的单链表
[数据结构]----链表(无头单向非循环链表的实现)
m0_68468727的博客
11-12 208
链表(无头单向非循环链表的实现)
不带头结点的单链表常用操作（一）
weixin_54818033的博客
12-31 1210
不带头结点单链表的常用操作
【数据结构】单链表（无头单向非循环链表）的实现
m0_52347974的博客
01-06 386
单链表
【数据结构】超详细--单向链表
joes_ju的博客
11-14 743
保姆级，超详细的C语言来实现数据结构的单向非循环链表功能
数据结构：线性表之-单向链表(无头)
2301_77649794的博客
09-05 1182
单向链表是一种常见的线性数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只能访问它后面的节点，而不能访问前面的节点。每个节点包含数据和指向下一个节点的指针。最后一个节点的指针指向空值（NULL），表示链表的结束。可以动态地添加或删除节点，链表的长度可以根据需要进行扩展或缩小。可以根据指针迅速插入或删除节点，而不需要移动其他节点。优点：插入和删除元素的时间复杂度为O(1)，不需要像数组一样进行元素的移动；链表长度可以动态调整，没有固定大小的限制。
【数据结构】无头+单向+非循环链表的增删查改（结尾附源码）
fbzhl的博客
05-15 217
链表中最基础的结构——无头单向非循环链表的增删查改的实现（超详细讲解，评论区可自由交流）
编写算法实现带头结点单链表的就地逆置
04-24
OK，我可以为您提供一个实现带头结点单链表的就地逆置的算法。代码如下： ```C++ void ReverseList(Node *head) { if (head == NULL || head->next == NULL) { return; } Node *p = head->next; Node *q = p->...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值