C++实现单链表的操作

最新推荐文章于 2022-12-03 00:22:06 发布
最新推荐文章于 2022-12-03 00:22:06 发布
阅读量292 收藏 3
点赞数 2
分类专栏： 算法和数据结构 文章标签： 单链表 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sqrt_2/article/details/100530831
版权
1.【定义】

  单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。

2.【示例代码】

singlyLinkedList.h

#define OK 1
#define ERROR 0
typedef int DataType;

typedef struct Node
{
	DataType _data;
	struct Node* _next;
	Node(){}
	Node(DataType x) :_data(x), _next(NULL) {}
}LNode, *LinkList;

class LinkedList
{
public:
	LinkedList();                      //构建一个单链表;
	~LinkedList();                  //销毁一个单链表;
	void CreateLinkList(DataType n);   //创建一个单链表
	void showLinkList();        //遍历线性表
	int GetLength();              //获取线性表长度
	bool IsEmpty();               //判断单链表是否为空
	LNode* Find(DataType data); //查找节点
	void InsertElemAtEnd(DataType data);            //在尾部插入指定的元素
	void InsertElemAtIndex(DataType data, int n);    //在指定位置插入指定元素
	void InsertElemAtHead(DataType data);           //在头部插入指定元素
	void DeleteElemAtEnd();       //在尾部删除元素
	void DeleteAll();             //删除所有数据
	void DeleteElemAtPoint(DataType data);     //删除指定的数据
	void DeleteElemAtHead();      //在头部删除节点
private:
	LNode *head;
};

singlyLinkedList.cpp

LinkedList::LinkedList()
{
	head = new LNode();
	head->_data = INT_MAX;               //将头结点的数据域定义为0
	head->_next = NULL;            //头结点的下一个定义为NULL
}

void LinkedList::CreateLinkList(DataType n)
{
	LinkList pnew, ptmp;
	ptmp = head;

	if (n < 0)    //当输入的值有误时，处理异常
	{
		cout << "输入的节点个数有误" << endl;
		exit(EXIT_FAILURE);
	}

	for (int i = 0; i < n; ++i)
	{
		DataType data;
		cout << "请输入第" << i + 1 << "个值: ";
		cin >> data;

		pnew = new LNode(data);
		ptmp->_next = pnew;
		ptmp = pnew;
	}
}

void LinkedList::showLinkList()
{
	if (head->_next == NULL) 
	{
		cout << "链表为空表" << endl;
		return;
	}
	LinkList p = head;                 //另指针指向头结点
	while (p->_next != NULL)        //当指针的下一个地址不为空时，循环输出p的数据域
	{
		p = p->_next;               //p指向p的下一个地址
		cout << p->_data << " ";
	}
	cout << endl;
}

int LinkedList::GetLength()
{
	int count = 0;                  //定义count计数
	LinkList p = head->_next;        //定义p指向第一个结点
	while (p != NULL)                //当指针的下一个地址不为空时，count+1
	{
		count++;
		p = p->_next;                //p指向p的下一个地址
	}
	return count;                   //返回count的数据
}

bool LinkedList::IsEmpty()
{
	if (head->_next == NULL) 
	{
		return true;
	}
	return false;
}

LNode* LinkedList::Find(DataType data)
{
	LinkList p = head;
	if (p->_next == NULL) 
	{                           //当为空表时，报异常
		cout << "此链表为空链表" << endl;
		return ERROR;
	}
	else
	{
		while (p->_next != NULL)               //循环每一个节点
		{
			if (p->_next->_data == data)
			{
				return p->_next;                     //返回指针域
			}
			p = p->_next;
		}
		cout << "查无数据" << endl;
		return NULL;                           //未查询到结果
	}
}

void LinkedList::InsertElemAtEnd(DataType data)    //尾插
{
	LinkList newNode = new Node(data);    //定义一个Node结点指针newNode
	LinkList p = head;
	if (p->_next == NULL)
	{
		p->_next = newNode;
		return;
	}

	while (p->_next != NULL)
	{
		p = p->_next;
	}
	newNode->_next = p->_next;
	p->_next = newNode;
}

void LinkedList::InsertElemAtIndex(DataType data, int index)
{
	if (index < 1 || index > GetLength()+1)       //输入有误报异常
	{
		cout << "输入的值错误" << endl;
	}	
	else
	{
		LinkList ptemp = new Node(data);        //创建一个新的节点
		LinkList p = head;                    //创建一个指针指向头结点
		int i = 1;
		while (index > i)                      //遍历到指定的位置
		{
			p = p->_next;
			i++;
		}
		ptemp->_next = p->_next;                 //将新节点插入到指定位置
		p->_next = ptemp;
	}
}

void LinkedList::InsertElemAtHead(DataType data)
{
	LinkList newNode = new Node(data);    //定义一个Node结点指针newNode
	LinkList p = head;              //定义指针p指向头结点
	if (p->_next == NULL) 
	{          
		p->_next = newNode;
	}
	newNode->_next = p->_next;          //将新节点插入到指定位置
	p->_next = newNode;
}

void LinkedList::DeleteElemAtEnd()
{
	LinkList p = head;          //创建一个指针指向头结点
	LinkList ptemp = NULL;      //创建一个占位节点
	if (p->_next == NULL)
	{      
		cout << "单链表空" << endl;
	}
	else
	{
		while (p->_next != NULL)   //循环到尾部的前一个
		{
			ptemp = p;            //将ptemp指向尾部的前一个节点
			p = p->_next;          //p指向最后一个节点
		}
		delete p;                //删除尾部节点
		p = NULL;
		ptemp->_next = NULL;
	}
}

void LinkedList::DeleteAll()             //删除所有数据
{
	LinkList p = head->_next;
	LinkList ptemp = p;

	if (head->_next == NULL)
	{
		return;
	}

	if (p->_next == NULL)
	{
		head->_next = p->_next;
		delete ptemp;
		return;
	}

	while (p->_next != NULL)                    //在头结点的下一个节点逐个删除节点
	{
		ptemp = p;
		p = p->_next;
		head->_next = p;
		delete ptemp;
	}
	head->_next = NULL;                 //头结点的下一个节点指向NULL
}
void LinkedList::DeleteElemAtPoint(DataType data)     //删除指定的数据
{
	LinkList ptemp = Find(data);    //查找到指定数据的节点位置
	if (ptemp == NULL)
	{
		return;
	}

	if (ptemp == head->_next) 
	{
		DeleteElemAtHead();
	}
	else
	{
		LinkList p = head;          //p指向头结点
		while (p->_next != ptemp)      //p循环到指定位置的前一个节点
		{
			p = p->_next;
		}
		p->_next = ptemp->_next;         //删除指定位置的节点
		delete ptemp;
		ptemp = NULL;
	}
}

void LinkedList::DeleteElemAtHead()     //在头部删除节点
{
	LinkList p = head;
	if (p->_next == NULL)
	{ 
		cout << "该链表为空表" << endl;
	}
	else
	{
		LinkList ptemp = NULL;      //创建一个占位节点
		p = p->_next;
		ptemp = p->_next;              //将头结点的下下个节点指向占位节点
		delete p;                     //删除头结点的下一个节点
		p = NULL;
		head->_next = ptemp;           //头结点的指针更换
	}
}

LinkedList::~LinkedList()
{
	delete head;
}

main.cpp

int main()
{
	LinkedList L;

	L.CreateLinkList(3);
	cout << L.GetLength()<< endl;
	L.showLinkList();
	cout << "……………………………………………………………………"<< endl;
	L.InsertElemAtEnd(10);
	L.showLinkList();
	cout << L.GetLength() << endl;
	cout << "……………………………………………………………………" << endl;
	L.InsertElemAtIndex(29, 1);
	L.showLinkList();
	cout << L.GetLength() << endl;
	cout << "……………………………………………………………………" << endl;
	L.InsertElemAtIndex(55, 6);
	L.showLinkList();
	cout << L.GetLength() << endl;
	cout << "……………………………………………………………………" << endl;
	L.InsertElemAtHead(0);
	L.showLinkList();
	cout << L.GetLength() << endl;
	cout << "……………………………………………………………………" << endl;
	L.DeleteElemAtEnd();
	L.showLinkList();
	cout << L.GetLength() << endl;
	cout << "……………………………………………………………………" << endl;
	L.DeleteElemAtPoint(3);
	L.showLinkList();
	cout << L.GetLength() << endl;
	cout << "……………………………………………………………………" << endl;
	L.DeleteAll();
	L.showLinkList();
	cout << L.GetLength() << endl;
	cout << "……………………………………………………………………" << endl;
}
3.【测试结果】

在这里插入图片描述

sqrt_2
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++实现单链表基本操作
diviner_s的博客
01-18 5575
C++实现单链表基本操作 本博客按照上篇博客线性表单链表的基本操作而写出的完整代码，详情请看单链表基础概念 #include<iostream> using namespace std; //函数结果状态代码 #define OK 1 #define ERROR 0 typedef int Status; // Status 相当于 int typedef ...
C++ 实现单链表
Risingstar
04-23 456
#include <iostream> using namespace std; // 单链表的实现 template<typename _Ty> class SingleList { public: SingleList(); ~SingleList(); private: typedef struct tagNode // 节点定义 { _Ty _...
C++实现单链表的16种基本操作
weixin_47373497的博客
10-29 2460
C++实现单链表的16种基本操作 链表初始化，头插法创建链表，尾插法创建链表，取值，查找（第i个节点的数据域或者数据域为某个特定值的节点），有顺序的合并两个链表，无顺序的合并两个链表，插入，删除，逆置链表，求链表的节点个数，删除数据域重复的节点，输出链表，判空，置空链表。 以下是我写的头文件的代码 #ifndef DANLIANBIAO_H #define DANLIANBIAO_H #endif #include<iostream> #include<stdio.h> #inclu
C++实现单链表【每一步详细深入讲解，代码清晰、简单、易懂】
weixin_55755506的博客
12-03 4643
例如：我们需要在伪头节点（不包含数据）和含有1的节点之间插入一个节点，发现，只需要改变dummy的指针和需要插入的指针即可。通过对插入和删除的讨论，我们了解到，插入调用find函数时，并不需要操作其返回值，所以，返回值具体是该元素的节点还是其前面的节点并没有影响；，而第一个节点的前一个节点是dummy，这也是为什么我们需要dummy这个伪头节点。，因此，删除操作时我们必须得到需要删除节点的前一个节点，因此。先将要添加的元素的指针指向dummy节点的后一个节点。将要添加节点的指针指向之前的下一个节点。
单链表（C++实现）
qq_39559641的博客
04-07 3937
一、实验要求 (1).尾插法创建单链表，打印创建结果。 (2).头插法创建单链表，打印创建结果。 (3).销毁单链表。 (4).求链表长度。 (5).求单链表中第i个元素（函数），若不存在，报错。 (6).在第i个结点前插入值为x的结点。 (7).链表中查找元素值为x的结点，成功返回结点指针，失败报错。 (8).删除单链表中第i个元素结点。 (9).在一个递增有序的单链表L中插...
最详细的C++单向链表实现
qq_41696018的博客
08-15 1万+
链表是数据结构中常见的一种数据存储形式，其在物理存储单元上是非连续的存储结构，即其数据存储的空间并非连续的内存空间。这种存储方式的优点是可以动态分配内存空间，不会造成内存的浪费和溢出，同时链表对于执行插入、删除等操作十分简便，不需要移动大量元素，但是其相对于连续空间存储的数据相比，遍历速度较慢。 1、那么链表到底长啥样呢？ 链表由多个node(节点)组成，每个节点中由两部分结构组成，data中存储需要存储的数据，next为一个指针，其指向下一个node的地址。 当...
C++实现单链表（含完整代码）
热门推荐
Henry的博客
03-28 2万+
C++实现单链表（含完整代码） 使用C++实现单链表的基本操作 1、创建单链表 2、遍历单链表 3、插入单链表元素 4、单链表删除元素 5、判断单链表是否为空 6、单链表的长度 7、查找单链表元素 完整代码： #include <iostream> using namespace std; struct List { int val; struct List*.........
C++实现单链表的构造
08-19
今天，我们将详细介绍C++实现单链表的构造，包括链表的定义、常用函数的实现、链表的操作等方面的内容。 一、链表的定义 在C++中，我们可以使用模板类来定义链表。链表的每个节点由两个部分组成：数据域和指针域。...
使用C++实现单链表的基本操作：1、创建单链表2、遍历单链表3、单链表插入4、删除单链表5、判断是否为空6、单链表的
03-27
以上就是C++实现单链表的基本操作。理解并熟练运用这些操作，对于学习更高级的数据结构和算法至关重要。通过练习，你可以更好地掌握C++中的动态内存管理以及指针操作，这些都是编程能力的重要组成部分。
c++实现单链表
03-29
用c++实现单链表，单链表的每个结点的地址存放在其直接前驱结点的指针域中。其中第一个结点没有前驱结点，因此需要一个头指针指向第一个节点，便于我们对整个链表进行操作；这里的单链表的最后一个节点的指针域存放...
C/C++实现单向链表
01-16
分别用C和C++实现了单向链表（创建链表，插入数据、获取指定位置的数据、删除指定位置的数据...），如果在使用中觉得api不够用可以进行扩展；其中包含测试。
用c++类模板，实现的单链表基本操作
05-14
#include "stdafx.h" #include #include using namespace std; template struct LNode { T data; LNode *next; }; template class LinkList { public: LinkList(){L = 0;}//构造函数 ~LinkList();//析构函数，销毁单链表 void CreateList_L(int n);//构造单链表 bool IsEmpty() const{return L->next == 0;}//判断单链表是否为空 int GetElem_L(int i,T &e) const;//当第i个元素存在时，其值赋给e int ListInsert_L(int i,T &e);//在第i个位置插入元素e ……………………
c++实现单链表基本操作
11-24
本文将详细探讨如何实现带头结点单链表的基本操作，包括逆序建立链表、插入和删除等操作。 首先，我们定义单链表节点的结构体： ```cpp struct ListNode { int data; // 存储数据 ListNode* next; // 指向下一个...
C++实现单链表删除倒数第k个节点的方法
08-30
本文将详细介绍C++实现单链表删除倒数第k个节点的方法，并结合实例形式分析了C++单链表的定义、遍历及删除相关操作技巧。 单链表结构定义 在C++中，单链表可以使用结构体来定义，每个节点包含一个数据域和一个指向...
C++实现单链表（Single Linked List）
weixin_42133358的博客
05-14 7876
C++实现单链表（Single Linked List） 语言这个东西不用真的会忘， 我记得前前后后C++的基本语法我也看了好几遍了，一直没有动手写过什么东西，所以一遍遍的看，一遍遍的忘… … 正好最近在看数据结构，想着自己用C++来实现一下，一方面是熟悉整个逻辑过程，加深对数据结构的理解，另一方面，也熟悉一下C++。 单链表是线性表的链式存储结构，同顺序存储结构（可以理解为C++中的数组）不同的是，单链表在插入和删除一个结点时，不需要移动大量的元素，但是单链表没有数组中索引的概念，所以在查询一个元素
C++实现单链表
琅嬛福地
04-13 375
本篇介绍如何用C++实现单链表 首先需要定义节点 Node.h #ifndef NODE_H #define NODE_H class Node { public: int data; Node *next; public: void printNode(); }; #endif Node.cpp #include "Node.h" #include <iostream> using namespace std; void Node::printNode() { cout &l
数据结构C++实现单链表以及各种操作！
qq_58240448的博客
06-30 2803
使用c++实现的单链表以及各种操作，入插入、删除等！
用c＋＋实现单链表的操作
最新发布
03-28
以下是用C++实现单链表操作的示例代码： ```cpp #include <iostream> using namespace std; // 定义链表节点结构体 struct ListNode { int val; // 存储节点的值 ListNode *next; // 指向下一个节点的指针 ListNode(int x) : val(x), next(NULL) {} // 构造函数 }; // 定义链表类 class LinkedList { public: LinkedList() { // 构造函数 head = NULL; } ~LinkedList() { // 析构函数 ListNode *cur = head; while (cur != NULL) { ListNode *temp = cur; cur = cur->next; delete temp; } } void add(int val) { // 添加节点 if (head == NULL) { head = new ListNode(val); } else { ListNode *cur = head; while (cur->next != NULL) { cur = cur->next; } cur->next = new ListNode(val); } } void remove(int val) { // 移除节点 if (head == NULL) { return; } if (head->val == val) { ListNode *temp = head; head = head->next; delete temp; } else { ListNode *cur = head; while (cur->next != NULL && cur->next->val != val) { cur = cur->next; } if (cur->next != NULL) { ListNode *temp = cur->next; cur->next = cur->next->next; delete temp; } } } void print() { // 打印链表 ListNode *cur = head; while (cur != NULL) { cout << cur->val << " "; cur = cur->next; } cout << endl; } private: ListNode *head; // 链表头指针 }; int main() { LinkedList list; list.add(1); list.add(2); list.add(3); list.print(); // 输出：1 2 3 list.remove(2); list.print(); // 输出：1 3 return 0; } ``` 该代码实现了单链表的添加、移除和打印操作。需要注意的是，析构函数需要手动释放链表中所有节点的内存，否则可能会出现内存泄漏的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值