数据结构笔记二_线性表的链式存储结构（C++）

最新推荐文章于 2024-05-11 21:40:41 发布
最新推荐文章于 2024-05-11 21:40:41 发布
阅读量488 收藏
点赞数 2
分类专栏： C++ 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51352359/article/details/120663523
版权
本文介绍了如何使用C++模板类和内嵌结构实现单链表，包括链表类的定义、构造函数、基本操作（长度、搜索、访问、插入、删除和清空）以及遍历。实例演示了如何在链表中插入和删除元素，以及一个实际应用案例：字符串首字符删除并插入中间位置。
摘要由CSDN通过智能技术生成

线性表

线性表的基本定义和顺序存储的实现见上一篇博客：https://blog.csdn.net/weixin_51352359/article/details/120497500

线性表的链式存储结构——以单链表为例

线性表的抽象类

首先依据线性表要实现的功能，定义线性表的类模板即父类（当然这一步也可以不做）：

template<class elemType>
class list {
public:
	//对于属性类的函数，因其并不改变原数组or链表的值，在后面加const
	//可以达到保护隐含this指针以及供常对象使用的目的
	virtual int length() const = 0;
	virtual int search(const elemType& x) const = 0;
	//const &结构：在数据类型未知or比较复杂时，可以提高运行效率，同时节省空间
	virtual elemType visit(int i) const = 0;

	//数据操纵类函数
	virtual void insert(int i, const elemType& x) = 0;
	virtual void remove(int i) = 0;
	virtual void clear() = 0;

	//遍历操作
	virtual void traverse()const = 0;

	//析构函数,防止内存泄露
	virtual ~list() {};
};

单链表类的定义

关于单链表的一些基本概念，可以参考以前的博客：
https://blog.csdn.net/weixin_51352359/article/details/120471969

单链表的存储映像图如下：
在这里插入图片描述
描述单链表只需要一个指向头结点的指针型变量——头指针，这里用head指针。

  • 利用内嵌类
//单链表类的定义
template<class elemType>
class linkList :public list<elemType> {
private:
	struct node {//内嵌类
		elemType data;
		node* next;
	//构造函数
	node(const elemType& x, node* p = NULL) { data = x; next = p; }
	node():next(NULL){}
	//析构函数
	~node(){}
	}
	node* head;
public:
	linkList();
	~linkList() { clear(); delete head; }
	int length() const;
	int search(const elemType& x)const;
	elemType visit(int i)const;
	void insert(int i, const elemType& x);
	void remove(int i);
	void clear();
	void traverse()const;
};

基本操作实现

  • 构造类
  1. 构造函数
template<class elemType>
linkList<elemType>::linkList() {
	head = new node();
}
  • 属性类
  1. 求链表的长度
    从首节点开始，沿着后继指针链一个一个往后数，数到一个节点长度加1
template<class elemType>
int linkList<elemType>::length() {
	int count = 0;
	node* p = head->next;//指向首节点
	while (p != NULL) {
		count++; p = p->next;
	}
	return count;
}
  1. 搜索某个元素在线性表中是否存在,并返回元素下标
template<class elemType>
int linkList<elemType>::search(const elemType& x)const {
	//首节点位置为0
	int pos = -1;
	node* p = head->next;
	while (p) {
		pos++;
		if (p->data == x)break;
		p = p->next;
	}
	if (!p) return-1;//并未找到
	return pos;
}
  1. 访问某个元素
template<class elemType>
elemType linkList<elemType>::visit(int i)const {
	//判断i是否出界，若出界则直接跳出
	if (i<0 || i>length()) throw OutOfBound();
	int count = 0;
	node* p = head->next;
	while (p) {
		if (count == i)break;
		else {
			count++;
			p = p->next;
		}
	}
	return p->data;
}
  • 操纵类
  1. 在位置i插入某个元素x
    首先考虑最简单的情况，即在首节点后插入一个节点（首席插入法）
tmp = new node(x);//新建节点
tmp->next = head->next;//使自己指向下一个节点
head->next = tmp;//使上一个节点指向自己，链入完毕

之后考虑一般情况，即在第i个位置插入元素。由上述可知，在定位到第i-1个元素后，元素的插入就变得很简单了，故主要分为一下几步：

  • new一个新节点tmp存储元素
  • 使指针p指向第i-1个元素
  • 链入链表
//在第i-1个后面插入
template<class elemType>
void linkList<elemType>::insert(int i, const elemType& x) {
	if (i<0 || i>length()) throw OutOfBound();
	node* tmp;
	tmp = new node(x);//node的构造函数
	//使p指向第i-1个节点
	int count = 0;
	p = head;
	while (count < i) {
		p = p->next;
		count++;
	}
	//链入tmp
	tmp->next = p->next;
	p->next = tmp;
}
  1. 删除第i个位置的元素
    同上，删除首节点最为简单：
node* tmp = head->next;
if (!tmp)return;//注意： tmp可能为空！！
head->next = tmp->next;
delete tmp;

之后进入到一般情况：

template<class elemType>
void linkList<elemType>::remove(int i) {
	if (i<0 || i>=length()) throw OutOfBound();
	//让p指向第i-1个位置
	node* q,*p = head;
	int count = 0;
	while (count < i) {
		p = p->next;
		if (!p)return;//如果p为空，则直接返回 和上面的边界判定其实有重合
		count++;
	}
	q = p->next;
	if (!q) return;
	p->next = q->next;
	delete q;
}
  1. 清除一个线性表clear（）
template<class elemType>
void linkList<elemType>::clear() {
	//第一种方法：永远删首节点
	node* p = head->next;
	while (p) {
		head->next = p->next;
		delete p;
		p = head->next;
	}
	head->next = NULL;
	/*
	//第二种方法：兄弟协同法
	node* p = head->next, * q;
	head->next = NULL;
	while (p) {
		q = p->next;
		delete p;
		p = q;
	}
	*/
	}
  • 遍历类：即将线性表中的所有元素输出
template<class elemType>
void linkList<elemType>::traverse() {
	node* p = head->next;
	while(p)
	{
		cout << p->data << " ";
		p = p->next;
	}
}

代码集合清单

  • 头文件
    并未使用父类，主要利用友元实现，其中要注意node类的使用。如若不用友元，代码中也提供了另一种实现方式。
//文件名：linklist.h
#include<iostream>
using namespace std;

class outOfBound {};

/*
//类模板的定义
//在使用这种情况时，node可以直接使用，而不用使用node<elemType>
template<class elemType>
class linkList {
private:
	struct node {
		elemType data;
		node* next;
		node(const elemType& x, node* p = NULL) { data = x; p = next; }
		node() :next(NULL) {}
		~node() {}
	};
	node* head;
public:
	linkList();
	~linkList() { clear(); delete head; }
	int length()const;
	int search(const elemType& x)const;
	elemType visit(int i)const;
	void insert(int i, const elemType& x);
	void remove(int i);
	void clear();
	void traverse()const;
};
*/

//如果用下面这种方式定义，node需用node<elemType>
template<class elemType>
class linkList;//前声明
template<class elemType>
class node {
	friend class linkList<elemType>;
private:
	elemType data;
	node* next;
public:
	node(const elemType& x, node* p = NULL) {
		data = x; next = p;
	}
	node() :next(NULL) {}
};

template<class elemType>
class linkList {
private:
	node<elemType>* head;
public:
	linkList();
	~linkList() { clear(); delete head; }
	int length()const;
	int search(const elemType& x)const;
	elemType visit(int i)const;
	void insert(int i, const elemType& x);
	void remove(int i);
	void clear();
	void traverse()const;
};


//基本操作实现
template<class elemType>
linkList<elemType>::linkList() {
	head = new node<elemType>();
}

template<class elemType>
int linkList<elemType>::length() const{
	//首节点长度为1
	int count = 0;
	node<elemType>* p = head->next;
	while (p) {
		count++;
		p = p->next;
	}
	return count;
}

template<class elemType>
int linkList<elemType>::search(const elemType& x)const {
	//首节点下标为0
	int count = 0;
	node<elemType>* p = head->next;
	while (p) {
		if (p->data == x)break;
		else count++;
		p = p->next;
	}
	if (!p)return -1;
	else return count;
}

template<class elemType>
elemType linkList<elemType>::visit(int i)const {
	//首节点下标为0
	if (i<0 || i>length() - 1) throw outOfBound();
	int count = 0;
	node<elemType>* p = head->next;
	while (p) {
		if (count == i) break;
		count++;
		p = p->next;
	}
	return p->data;
}

template<class elemType>
void linkList<elemType>::insert(int i, const elemType& x) {
	if (i<0 || i>length()) throw outOfBound();
	node<elemType>* tmp = new node<elemType>(x);
	node<elemType>* p = head;
	int count = 0;
	while (p) {
		if (count == i) break;
		count++;
		p = p->next;
	}
	tmp->next = p->next;
	p->next = tmp;
}

template<class elemType>
void linkList<elemType>::remove(int i){
	if (i<0 || i>length()-1) throw outOfBound();
	int count = 0;
	node<elemType>* p = head;
	while (p) {
		if (count == i) break;
		count++;
		p = p->next;
	}
	node<elemType>* tmp = p->next;
	p->next = tmp->next;
	delete tmp;
}

template<class elemType>
void linkList<elemType>::clear() {
	node<elemType>* p = head->next;
	head->next = NULL;
	if (!p) return;
	node<elemType>* q = p->next;
	while (q) {
		delete p;
		p = q;
		q = p->next;
	}
	delete p;
}

/*
template<class elemType>
void linkList<elemType>::clear() {
	node* p = head->next;
	while (p) {
		head->next = p->next;
		delete p;
		p = head->next;
	}
}
*/

template<class elemType>
void linkList<elemType>::traverse() const {
	node<elemType>* p = head->next;
	while (p) {
		cout << p->data << " ";
		p = p->next;
	}
}
  • 主函数
    功能测试，将一个字符串的首字符删除并插入到中间位置
#include<iostream>
#include"linklist.h"
using namespace std;

int main() {
	linkList<char> chlist;

	char ctemp;
	int i, n, result;

	cout << "number of the elements:" << endl;
	cin >> n;
	cin.get(ctemp);//将enter抛弃

	cout << "input the elements:\n" << endl;
	//将字符逐个输入到表中，并依次插入表尾
	for (i = 0; i < n; i++) {
		cin.get(ctemp);
		chlist.insert(i, ctemp);
	}
	ctemp = chlist.visit(0);//获得首节点
	chlist.remove(0);//将首节点删除
	chlist.insert((chlist.length() + 1) / 2, ctemp);//将删除的首节点放在中间位置

	cout << "output the elements:\n" << endl;
	for (i = 0; i < chlist.length(); i++) {
		cout.put(chlist.visit(i));//读取第i个节点的值并输出
	}
	cout << endl;
	cout << endl;
	chlist.traverse();//遍历输出
	cout << endl;
	cout << endl;
	cout << chlist.search('a');
	return 0;
}
  • 代码运行结果：
    在这里插入图片描述

扩展：就地逆置

利用首席插入法和兄弟协同法实现单链表的就地逆置：
（下图为具体思路图示）
在这里插入图片描述
代码清单：

template<class elemType>
void linkList<elemType>::reverse() {
	node<elemType>* p, *q;

	p = head->next;
	head->next = NULL;

	while (p) {
		q = p->next;
		p->next = head->next;
		head->next = p;
		p = q;
	}
}

代码运行结果(最后一行为上一行的reverse（））:
在这里插入图片描述

应用：求集合交集

#include<iostream>
#include"linklist.h"
using namespace std;

int main() {
    linkList<int> list1, list2, list3;
    int i = 0, j, x;
    int len1;

    //输入第一个集合中的元素
    cout << "请输入第一个集合中元素：(以0作为结束标志）";
    cin >> x;
    while (x != 0)
    {
        list1.insert(i, x);
        i++;
        cin >> x;
    }

    //输入第二个集合的元素
    i = 0;
    cout << "请输入第二个集合中元素：(以0作为结束标志）";
    cin >> x;
    while (x != 0)
    {
        list2.insert(i, x);
        i++;
        cin >> x;
    }

    //查找list1中的元素是否在list2中出现
    //如果出现则将其存入list3中
    len1 = list1.length();
    int num = 0;
    for (j = 0; j < len1; ++j) {
        int y = list1.visit(j);
        if (list2.search(y) != -1) {
            list3.insert(num, y);
            num++;
        }
    }

    //输出list3
    list3.traverse();
}

运行结果：
在这里插入图片描述

补充：双链表的实现

在这里插入图片描述
基本要素：

  • node* head
  • node*tail
  • currentlength

代码清单：

//文件名：DlinkList.h
#include<iostream>
using namespace std;

template<class elemType>
class DlinkList {
private:
	struct node {
		elemType data;
		node* prior, * next;
		node(const elemType& x, node* p = NULL, node* q = NULL) {
			data = x; prior = p; next = q;
		}
		node():next(NULL),prior(NULL){}
		~node(){}
	};
	node* head, * tail;
	int currentlength;
	node* move(int i)const;//返回第i个节点的地址
public:
	DlinkList();
	~DlinkList() { clear(); delete head; delete tail; }
	void clear();
	int length()const { return currentlength; }
	int search(const elemType& x)const;
	elemType visit(int i)const;
	void insert(int i, const elemType& x);
	void remove(int i);
	void traverse();
	void reverse();
};

template<class elemType>
DlinkList<elemType>::DlinkList() {
	head = new node;
	head->next = tail = new node;
	tail->prior = head;
	currentlength = 0;
}

template<class elemType>
typename DlinkList<elemType>::node* DlinkList<elemType>::move(int i)const {
	node* p = head->next;
	while (i--) p = p->next;
	return p;
}

template<class elemType>
int DlinkList<elemType>::search(const elemType& x)const {
	node* p = head->next;
	int i;
	for (i = 0; i < currentlength; ++i) {
		if (p->data == x)break;
		p = p->next;
	}
	if (i == currentlength)return-1;
	else return i;
}

template<class elemType>
elemType DlinkList<elemType>::visit(int i)const {
	return move(i)->data;
}

template<class elemType>
void DlinkList<elemType>::clear() {
	node* p, * q;
	p = head->next;
	while (p!=tail) {
		q = p->next;
		delete p;
		p = q;
	}
	head->next = NULL;
	tail->prior = head;
	currentlength = 0;
}

template<class elemType>
void DlinkList<elemType>::insert(int i, const elemType& x) {
	node* p, * tmp;
	p = move(i);//找到第i个节点
	tmp = new node(x, p->prior, p);
	p->prior->next = tmp;
	p->prior = tmp;
	++currentlength;
}

template<class elemType>
void DlinkList<elemType>::remove(int i) {
	node* p;
	p = move(i);
	p->prior->next = p->next;
	p->next->prior = p->prior;
	delete p;
	--currentlength;
}

template<class elemType>
void DlinkList<elemType>::traverse() {
	node* p = head->next;
	while (p != tail) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}

template<class elemType>
void DlinkList<elemType>::reverse() {
	node* p;

	for (p = tail->prior; p != head; p = p->prior) {
		cout << p->data;
	}
}

例题

题目描述
给定一个N个数的数组，M次操作，每次操作为下列操作之一。求最后的数组。

操作1：在第X个数之后插入一个数Y。

操作2：删除第X个数。

输入格式
第一行：两个整数N，M（N，M≤100000）含义见试题描述。

第二行：N个整数，表示原来的数组。

接下来M行，每行第一个数OP，表示操作类型。

对于操作1，接下来两个数X，Y，含义见题面描述，保证0≤X≤当前数的个数，若X=0，表示在数组开头插入。

对于操作2，接下来一个数X，含义见题面描述，保证1≤X≤当前数的个数。

输出格式
输出若干个数，表示最后的数组。
样例输入
5 3
1 2 3 4 5
1 1 6
2 1
2 2
样例输出
6 3 4 5

代码清单：

#include<iostream>
using namespace std;

struct ListNode {
	int value;
	ListNode* next;
	ListNode(int val) :value(val), next(NULL) {};
	ListNode() :value(0), next(NULL) {};
};

void _insert(ListNode* head, int pos, int value) {
	ListNode* pre = head, * cur = head;

	for (int i = 0; i <= pos; ++i) {
		pre = cur;
		cur = cur->next;
	}

	ListNode* to_insert = new ListNode(value);
	pre->next = to_insert;
	to_insert->next = cur;
}

void _delete(ListNode* head, int pos) {
	ListNode* pre = head, * cur = head;

	for (int i = 1; i <= pos; ++i) {
		pre = cur;
		cur = cur->next;
	}
	pre->next = cur->next;
	cur = cur->next;
}

int main() {
	int n, m;
	cin >> n >> m;

	ListNode* head = new ListNode(),*cur = head;

	for (int i = 0; i < n; i++) {
		int t;
		cin >> t;
		ListNode* tmp = new ListNode(t);
		cur->next = tmp;
		cur = cur->next;
	}

	int c;
	for (int i = 0; i < m; ++i) {
		cin >> c;

		if (c == 1) {
			int insert_value,pos;
			cin >> pos >> insert_value ;
			_insert(head, pos, insert_value);
		}
		else {
			int pos;
			cin >> pos;
			_delete(head, pos);
		}
	}

	ListNode* p = head->next;

	while (p) {
		cout << p->value <<" ";
		p = p->next;
	}

	return 0;
}

运行结果：
在这里插入图片描述

H.A.N.118
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表的链式存储结构（c++实现）
qq_29131907的博客
03-22 1627
链表是一种动态数据结构，他的特点是用一组任意的存储单元（可以是连续的，也可以是不连续的）存放数据元素。链表中每一个元素成为“结点”，每一个结点都是由数据域和指针域组成的，每个结点中的指针域指向下一个结点。Head是“头指针”，表示链表的开始，用来指向第一个结点，而最后一个指针的指针域为NULL(空地址)，表示链表的结束。可以看出链表结构必须利用指针才能实现，即一个结点中必须包含一个指针变量，用来存...
C++线性表的链式存储结构
BeiXi's Blog
09-20 1665
实现链表 template<class T> void LinkList<T>::Print() { LinkNode<T> *tmp = _head; while (tmp != NULL) { cout << tmp->_data << "-->"; tmp = tmp->_next; } cou...
东方博宜1501 - 数的操作
最新发布
kuaidihezi的博客
05-11 464
给定一个 N 个数的数组， M 次操作，每次操作为下列操作之一。求最后的数组。操作 1 ：在第 X 个数之后插入一个数 Y。操作 2 ：删除第 X 个数。
C++线性表链式存储结构
LLLCSDN的博客
12-11 2199
本来想要在头结点的数据域存放链表长度，结果后来这样反而出了一些麻烦#include using namespace std; #define MAXSIZE 123 typedef int ElemType;//为复杂的声明定义简单的别名 struct Node { ElemType date; Node *next; Node(ElemType elem); }; Node::N
线性表的链式存储结构c++
weixin_43790360的博客
08-22 229
《数据结构》（第2版）陈越 #include <iostream> using namespace std; typedef struct LNode *PtrToLNode; struct LNode{//定义链表结点的结构 int Data; PtrToLNode Next; }; typedef PtrToLNode Position;//代表结点的地址 typedef PtrToLNode List; int Length(List L){//1..
C++数据结构--线性表的链式存储结构
m0_73443478的博客
02-08 375
C++数据结构--线性表的链式存储结构
数据结构笔记(C++版)
01-20
本篇将详细介绍《数据结构笔记(C++版)》中的关键知识点，帮助读者深入理解数据结构的基础概念及其在C++中的实现。 #### 二、数据结构的核心概念 1. **数据**: 能够被计算机处理的各种符号的集合，包括数字、字符、...
数据结构视频教程学习笔记
12-19
在本教程的第二章中，我们深入研究了线性表的顺序存储结构，即顺序表。顺序表通常使用一维数组实现，数组下标从0开始，而线性表元素序号从1开始。这导致逻辑位序和物理位序相差1。顺序表的操作包括初始化、销毁、...
数据结构笔记精华.docx
07-06
"数据结构笔记精华" 本资源是一个详细的数据结构笔记，涵盖了数据结构的基本概念、算法和实现方法。笔记共分为多章节，每章节都对应着特定的主题。下面是资源的详细知识点摘要： 绪论 * 什么是数据结构？数据结构...
青岛大学王卓数据结构与算法课程PPT截图
02-17
"线性表的类型定义"则会涉及如何在程序中定义线性表的数据结构，如在C++或Java中的定义方式。 以上只是王卓教授课程的部分内容概述，完整的PPT应该还包括对栈、队列、树、图等其他数据结构的深入讲解，以及排序和...
数据结构培训笔记 c/c++
10-27
线性表可以是顺序存储或链式存储，例如数组是最常见的线性数据结构，它占用连续的内存空间。栈遵循“后进先出”原则，常用于函数调用和表达式求值；队列则遵循“先进先出”原则，常用于任务调度。数组的地址计算通常...
线性表的链式存储结构c++模板类实现
06-20
哈工大软设设计与开发实践1的课程要求代码，个人写的很粗糙简陋，仅供参考
数据结构之线性表的链式存储结构
11-06
数据结构线性表的链式存储结构，使用c语言完成。线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素。
C++实现线性表的链式存储结构（单链表）
cloudYun的博客
02-15 2027
C++实现线性表的链式存储结构（单链表）       线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。也就是说，这些数据元素可以存储在未被使用的内存的任意位置。       链式存储结构中：存储数据元素信息的域称为...
[C++/数据结构]1.2 线性表的链式存储
weixin_43150072的博客
04-20 1235
线性表的链式存储
C++实现线性表链式存储结构的创建插入和删除
wyl1813240346的博客
07-07 3852
主函数为： #include &lt;iostream&gt; using namespace std; typedef int eletype; struct Node { eletype data; Node * next; }; //typedef struct Node *LinkList; void createLinkList(Node * L, int n);...
数据结构学习笔记第四节：线性表的链式存储C和C++的实现
y_927的博客
05-06 323
一、线性表链式存储结构的定义 1、线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的也可及时布偶连续的。即这些数据元素可以存储在内存未被占据的任意位置。 2、以前的顺序结构中，每个元素只需要存放数据元素就可以了。现在链式结构中，除了要存放数据元素的信息外，还要存储它的后继元素的存储地址。我们把存储数据元素信息的区域称为数据域，把存储直接后继位置的域称...
数据结构——线性表——链式存储结构——C++实现线性表
MISAYAONE的博客
05-13 1594
链式存储结构C++实现篇：主要实现了线性表的定义、初始化、显示、增、删结点、查找结点操作。 切记亲力亲为，动手实践写代码 main.cpp /*************************************************************************** * @file main.cpp
信息学奥赛第十四节 —— LIST链表
smallrain6的博客
05-11 1646
LIST的结构 list：链表。与vector与deque不同，它不要求计算机申请一片连续的空间。每个list都是由若干个结点构成的，而每个结点也包括三个部分： 存储的元素 指向前一个结点的指针 指向后一个结点的指针 list没有下标，因此需要使用迭代器进行访问。list不支持sort，但是其支持sort成员函数。 算法来源于生活，链表的结构，与灯笼类似。 LIST的一些函数 remove(val) —— 删除与val相等的所有元素 empty() —— 判断链表是否为空 reverse() ——
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值