【数据结构C++】线性表-链式存储：链表类型和单链表（定义+代码实现）

已于 2024-03-20 15:26:32 修改
阅读量1.1k 收藏 28
点赞数 17
分类专栏： 数据结构 文章标签： 数据结构 c++ 链表
于 2024-03-15 10:29:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JingYan_Chan/article/details/136721520
版权

系列文章目录

第一章 【数据结构C++】线性表/顺序表-数组与vector
第二章 【数据结构C++】线性表/顺序表-数据类型、增删改查操作
第三章 【数据结构C++】线性表/顺序表-实战：通信录
第四章 【数据结构C++】线性表-链式存储：链表类型和单链表（定义+代码实现）
第五章 【数据结构C++】线性表-链式存储：双链表、循环链表、静态链表（定义+代码实现）

文章目录

前言

我们用前三章内容介绍了线性表中的顺序存储的内容。我们知道，顺序表的优点是可随机存储且存储密度高，但是也存在不足：要求大片连续空间，改变容量不容易，插入和删除需要时间复杂度为O(N)。本章我们介绍线性表的链式存储——链表。

链表优点：不要求大片连续空间，改变容量方便；
缺点：不可随机存取，要耗费一定空间存放指针。

在这里插入图片描述

一、链表类型

四大类：单链表、双链表、循环链表、静态链表。
在这里插入图片描述
链表特点：将每个结点放在一个独立的存储单元中，结点间的逻辑关系依靠存储单元中附加的指针来给出。结点的存储单元在物理位置上可以相邻，也可以不相邻。简而言之，链表中各结点不一定放在连续的存储空间，而是依靠指针把他们连接在一起。
在这里插入图片描述

二、单链表

1. 存储结构

单链表中各个节点的存储结构如下：
在这里插入图片描述
在这里插入图片描述

2. 两种实现形式：带头结点和不带头结点

单链表分为带头结点和不带头结点两种。首先我们了解头指针、头结点和首元结点的含义。

  1. 头指针：指向链表中第一个结点（有头结点的指向头结点，无头结点则指向首元结点）的指针。单链表可由一个头指针唯一确定，能够标识一个单链表，也常做链表的名字。
  2. 头结点：在链表的首元结点之前附设的一个结点；数据域内只放空表标志，表长等信息或者是空的；也可做监视哨。
  3. 首元结点：指链表中存储线性表第一个数据元素的结点,也称为第一元素结点。
    在这里插入图片描述

不带头结点的单链表： 头指针指向第一个数据元素结点。
在这里插入图片描述
若链表为空，则只有头指针指向NULL：head->NULL。

带头结点的单链表： 指向空的头节点。
在这里插入图片描述
若链表为空，则只有头指针指向空的头结点。

头结点的意义：使得在表头位置上进行插入和删除和在其它非空结点位置上是完全一致的，从而使得插入和删除算法得到简化。
在这里插入图片描述

3. 类型定义（代码）

代码模板（伪代码）如下：

template <class elemType>
struct Node {
	public:
	elemType data;	// 数据域
	Node* next;		//指针域
	
	Node(const elemType value, Node* p= NULL){//两个参数的构造函数
	data = value;
	next = p;
	}
	Node(Node*p=NULL){//一个参数的构造函数
	next = p;
	}
};

此处插播一则关于C++中struct和typedef的语法小知识：
struct是声明一个结构体，它可以将不同类型的数据存放在一起，作为一个整体进行处理。例如：结点数据域data是elemType类型，指针域next是Node*类型，这俩个数据类型不同但是他们又是表示一个整体（单链表），所以用结构体struct把他们结合起来，形成一个新的数据类型。struct的声明需要放在main函数之前。
typedef：为类型取一个新的名字，例如：typedef int zhengshu; 意思是将int类型换一个新名字叫zhengshu。前面讲到指针域next是Node*类型，我们需要创建新结点时，内存中申请一个结点所需空间，并用指针p指向这个结点：

struct Node* p= (struct Node*) malloc (sizeof(struct Node*));

我们写了三次struct Node*，很麻烦，所以我们用typedef重命名Node*：

格式：typedef <eleType> <别名>
例子：typedef int zhengshu;

旧：int x=1;
新：zhengshu x=1;

回归单链表定义：
typedef struct Node Node;
新： Node* p= (Node*) malloc (sizeof(Node*));

具体定义代码：

typedef struct LNode{	//定义单链表结点类型
	ElemType data;		//每个节点存放一个数据元素
	struct LNode *next;		//指针指向下一个节点
}LNode, *LinkList;

这相当于：

typedef struct LNode LNode;
typedef struct LNode *LinkList;

4. 创建一个结点（代码）

要表示一个单链表时，只需声明一个头指针L，指向单链表的第一个结点。
LNode* L; //声明一个指针，该指针指向单链表第一个结点，强调返回一个结点
或
LinkList L; //声明一个指向单链表第一个结点的指针，强调返回一个单链表

若想在堆区开辟空间时，C是使用malloc函数，而在C++则是使用new关键字。利用C++语言的new和delete操作符给对象分配和释放空间：

Node<elemType>* p = new Node<elemType> (value,NULL);

p的类型为Node<elemType>*型，所以该无名结点可以用指针p间接引用，数据域为(*p).data或p->data，指针域为(*p).next或p->next。
在这里插入图片描述

5. 单链表完整定义模板（代码）

代码如下：

template <class elemType> //elemType为单链表存储的元素类型
class linkList: public List<elemType>{
	private:
		struct Node {	// 结点类型
			public:
				elemType data;//结点的数据域
				Node* next; //结点的指针域
				
				Node(const elemType value, Node* p= NULL){	// 两个参构造函数
					data = value;
					next = p;
				}
				
				Node(Node* p= NULL){	//一个参构造函数
					next = p;
				}
		};
				
		Node* head;		//单链表的头指针
		Node* tail;		// 单链表的尾指针
		int curLength;	//单链表的当前长度，牺牲空间换时间
		Node* getPosition(int i)const;// 返回指向位序为i的元素的指针
		
	public:
		linkList();// 构造函数
		~linkList();// 析构函数
		
		void clear();// 将单链表清空
		
		bool empty()const{ return head->next==NULL;}// 判空
		
		int size()const{ return curLength;}// 返回单链表的当前实际长度
	
		void insert(int i,const elemType &value);// 在位序i上插入一个元素value
	
		void remove(int i);// 删除位序i上的元素
	
		int search(const elemType&value)const;//查找值为value的元素第一次出现的位序
	
		int prior(const elemType&value)const;// 查找值为value的元素的前驱的位序
	
		elemType visit(int i)const;// 访问位序为i的元素值，0定位到首元结点
	
		void traverse()const;// 遍历单链表
		
		void headCreate();//“头插法“创建单链表
		
		void tailCreate()//“尾插法“创建单链表
		
		void inverse();// 逆置单链表							
};

尾指针的创建：尾指针的加入使得频繁修改表尾结点的值或后继时，无需从头遍历链表。
在这里插入图片描述

5. 各函数模板（代码）

5.1 初始化链表

template <class elemType>
linkList<elemType>::linkList(){
	head = tail = new Node(NULL);// 创建带有头结点的空表
	curLength=0;
}

//不带头结点的 
template <class elemType>
linkList<elemType>::linkList(){
	head=NULL;// 创建不带有头结点的空表
	curLength=0;
}

5.2 析构函数

时间复杂度为O(N) ：

template <class elemType>
linkList<elemType>::~linkList(){
	clear();	// 清空单链表
	delete head;	// 释放头结点
}

5.3 清空链表

主要操作是将工作指针从头结点一直移动到链表尾，边移动指针边释放结点。时间复杂度为O(N) ：

template <class elemType>
void linkList<elemType>::clear(){
	Node * p,* tmp;// p为工作指针，指向首元结点
	p= head->next;//引入工作指针是为了防止随意修改头指针
	
	while(p != NULL){// 等效while(p)
		tmp= p;
		p= p->next;// 指针后移
		delete tmp;
	}
	
	head->next=NULL;// 头结点的指针域置空
	tail = head;// 头尾指针均指向头结点
	curLength=0;
}

5.4 求表长

时间复杂度为O(1) ：

template <class elemType>
int linkList<elemType>::size()const{
	return curength;//直接返回curLength
}

//若没有curLength O(N)
template <class elemType>
int linkList<elemType>::size()const{ //若没有curLength
	Node *p =head->next;// 需要从头到尾遍历链
	int count=0;
	while(p){ count++;p=p->next;}
	return count;
}

5.5 遍历链表

时间复杂度：O(N)

template <cass elemType>
void linkList<elemType> ::traverse()const{
	Node *p= head->next;// 工作指针p指向首元结点
	cout << "traverse:";
	while(p != NULL){
		cout << p->data <<" ";
		p = p->next;	// 向后移动指
	}
	
	cout << endl;
}

5.6 查找位序i的元素 O(N)

template <class elemType>
typename linkList<elemType> :: Node* linkList<elemType> ::getPosition(int i)const {
	if(i<-1 || i>curLength-1)	// 合法查找位置为[-1..n-1]
		return NULL;			//当i非法时返回NULL
		
	Node *p= head;		// 工作指针p指向头结点
			
	int count = 0;
	
	while(count <=i){
		p = p-> next;
		count++;
	}
	
	return p;		// 返回指向位序为i的结点的指针
}

5.7 查找值为value的元素的位序 O(N)

emplate <class elemType>
int linkList<elemType> ::search(const elemType&value)const{
	Node*p= head->next;//工作指针p指向首元结点
	int count = 0;// 首元结点的位序为0
	while(p != NULL && p->data != value){
		p = p->next;
		count++;
	}
	
	if(p== NULL){
		return -1;		//查找失败返回-1，这里-1并非头结点
	}else{
		return count;			// 查找成功，count为元素的位序
	}	 
}

5.8 查找值为value的元素的前驱的位序

思想：求值为value的元素的前驱，需要从链表的第一个结点开始遍历链表。我们设置两个指针p和pre，分别指向当前正在访问的结点和它的前驱结点，还需要一个计数器count从链表的第一个结点开始遍历链表。
(1)若p== NULL，则查找值为value的元素失败，返回-1.
(2)若查找值为value的元素成功，且该元素是首元结点则无前驱，返回-1;
(3)若查找值为value的元素成功，且该元素不是首元结点，则返回其前驱的位序。

时间复杂度为O(n)。

template <class elemType>
int linkList<elemType> ::prior(const elemType&value)const{
	Node *p= head->next;//p是工作指针指向首元结点
	Node *pre = NULL;// pre指向p的前驱结点
	int count= -1;// 注意:-1表示首元结点无前驱
	
	while(p &&p->data != value){
		pre = p;// 前驱指针后移
		p = p->next;// 指向下个待处理结点
		count++;
	}
	
	if(p== NULL)	return -1;//查找失败返回-1，这里-1并非头结点
	else	return count;//查找成功，count为元素的位序
}

5.9 插入元素 O(N)

请添加图片描述

template <class elemType>
void linkList<elemType> :: insert(int i,const elemType &value){
	Node *p，*q;
	if(i<0 || i> curLength)	//合法的插入位置为[0..n]	
		throw outOfRange();	// 插入位置非法，抛出异常
	
	p= getPosition(i-1);// P是位序为i的结点的前驱
	q= new Node(value，p->next);// 申请新结点q
	p->next = q;// q结点插入到p结点的后面
	
	if(p == tail)
		tail = q;// 若插入点在表尾，q成为新的表尾
		
	curLength++;
}

5.10 删除元素 O(N)

template <class elemType>
void linkList<elemType>::remove(int i){
	Node *pre,*p;// p是待删结点，pre是其前驱
	if(i<0 || i> curLength-1)//合法的删除位置为[0..n-1]
		throw outOfRange();//当待删结点不存在时，抛出异常
	
	pre= getPosition(i-1);
	p = pre->next; // P是真正待删结点
	
	if(p == tail){// 待删结点为表尾结点，则修改尾指针
		tail = pre;
		pre->next=NULL;
	}else{
		pre->next=p->next;
	}
	delete p;
	curLength--;
}

5.11 常用——头插法

作用：创建单链表、逆置 。
时间复杂度为O(n) 。
头插法是在链表的头部插入结点建立单链表，也就是每次将新增结点插入在头结点之后，首元结点之前。
图中显示了根据线性表(5，4，3，2，1)创建带有头结点的单链表的过程，因为是在链表的头部插入，所以读入数据的顺序为1,2,3,4,5和线性表中的逻辑顺序是相反的。

请添加图片描述

// 头插法创建单链表
template <class elemType>
void linkList<elemType>:: headCreate(){
	Node *p;
	elemType value,flag;
	cout<<"input elements,ended with:";
	 
	cin>>flag;// 输入结束标志
	while(cin>>value,value != flag){
	//创建新结点: p->data=value,p->next= head->next;
	p= new Node(value,head->next);
	head->next= p;// 结点p插入到头结点的后面
	if(head == tail)	tail = p;// 原链表为空，新结点p成为表尾结点
	curLength++;
	}
}

5.12 常用——尾插法 O(N)

尾插法是在链表的尾部插入结点建立单链表，tail指针在这里起作用。

template <class elemType>  					
void linkList<elemType> ::tailCreate(){// 尾插法创建链表
    Node *p; 
    elemType value,flag;
    cout<<"input elements,ended with:";
    cin>>flag;				// 输入结束标志
    while(cin>>value,value!=flag){
        p=new Node(value,NULL);
        tail->next=p;			// 结点p插入到表尾结点的后面
        tail=p;				// 结点p成为新的表尾
        curLength++;
    }
}

请添加图片描述

5.13 逆置单链表

工作指针p依次访问链表中的每个结点，每访问一个结点，将它插入到头结点的后面（头插法）。
时间复杂度为O(n)。

template <class elemType>  
void linkList<elemType> :: inverse(){// 头插法逆置
    Node *p,*tmp;
    p=head->next;		// p为工作指针指向首元结点
    head->next=NULL;	// 头结点的指针域置空，构成空链表
    if(p)	tail=p;			// 逆置后，原首元结点将变成表尾结点
    while(p){
        tmp=p->next;		// 暂存p的后继
        p->next=head->next;		
        head->next=p;	// 结点p插入到头结点的后面
        p=tmp; 		// 继续处理下一个结点
    }
}

5.14 合并链表

非递减有序的单链表la和lb合并成新的非递减有序单链表lc，要求利用原表空间。
算法思想：因为新创建的单链表lc仍然是非递减有序的，所以用尾插法创建lc表。

template <class elemType> 
typename linkList<elemType> * linkList<elemType> ::Union(linkList<elemType> * lb){
    Node *pa,*pb,*pc;		// 分别是链表la、lb、lc的工作指针
    linkList<elemType>* lc = this;	// lc表利用la表空间
    pa=head->next;
    head->next=NULL;	// la表构成空链表
    pb=(lb->head)->next;  
    (lb->head)->next=NULL;// lb表构成空链表
    
    pc=lc->head;			// lc表直接利用la表头结点
    
	while(pa && pb){		// la和lb均非空
        if(pa->data<=pb->data) {	// pa所指结点尾插法插入lc表
            pc->next=pa;  pc=pa;  pa=pa->next;    
        }else{			// pb所指结点尾插法插入lc表
            pc->next=pb;  pc=pb;  pb=pb->next;   
        }
    }
    if(pa){ 			// 若pa未到尾，将pc指向pa
        pc->next=pa;						
        lc->tail=tail;		// 修改尾指针，因lc=la，这条语句可省略
    }else{
        pc->next=pb;		// 若pb未到尾，将pc指向pb
        lc->tail=lb->tail;	// 修改尾指针
    }
    
    lc->curLength = curLength+lb->curLength;
    delete lb;	 
    return lc;
}

总结

  1. 链表的特点：
    在这里插入图片描述

  2. 单链表时间复杂度的总结：
    查找：不支持随机存取，O(N).
    插入和删除：遍历链表，找到代操作结点的前驱结点，通过修改指针完成。O(N)+O(1)=O(N).

  3. 来自链接文章的总结表格。总结得很清晰，供大家一起学习。
    在这里插入图片描述

宇宙修理员
关注
  • 17
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表
boy_of_god的博客
08-29 364
文章目录1、链栈1.2、算法1.3实现1.3.1定义数据类型1.3.1.0功能代码1.3.1.1内存分析1.3.2创建一个链表1.3.2.0功能代码1.3.2.1内存分析1.3.3遍历链表1.3.3.0功能代码1.3.3.1内存分析1.3.4判断链表是否为空1.3.4.0功能代码1.3.4.1内存分析1.3.5求链表的长度1.3.5.0功能代码1.3.5.1内存分析1.3.6链表排序（基于冒泡）1...
2. 线性表-链式存储-链表1
08-03
线性表是计算机科学中基础的数据结构之一，它是由相同类型元素组成的有序序列。在实际应用中，线性表可以采用两种不同的存储方式：顺序存储和链式存储。本篇主要讨论的是链式存储，特别是链表这一实现方式。 链表是...
数据结构（C语言版）-线性表（单链表）
czh2637750821的博客
01-08 902
学习视频链接 单链表一、单链表1、单链表的定义2、单链表的类型定义3、单链表的基本操作实现二、配套实验 一、单链表 1、单链表的定义 线性表的链式存储结构是指用一组任意的存储单元存储线性表中的数据元素。为了反映数据元素之间的逻辑关系，对于每个数据元素不仅要表示它的具体内容，还要附加一个表示它的直接后继元素存储位置的信息这样构成的链表为单链表。其结点分为数据域与指针域 ，单链表分为带头结点和不带头结点两种类型。 数据域 指针域 data next 结点：数据元素的存储映像 链表：n个结
C C++最新链表（基础详解、实现、OJ笔试题），2024年最新写给程序员的Flutter详细教程
最新发布
2401_84976104的博客
05-15 713
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。非连续的意思就是链表的每一部分可以在内存的任意一块区域存在，且这块区域的地址是随机的，所以一般用动态内存来开辟这块空间的地址。数据域和指针域，通过指针域即可访问其他结点的数据。
单链表及其常用操作（C++）
Slumberrrr的博客
05-05 388
int data;//数据域//指针域//对第二个别名的分析：LinkList等价于struct LNode*//使用LinkList创建的量为指向结构体的指针//而使用LNode创建的量为结构体本身。
一篇解单链表（0基础看）（C语言）《数据结构与算法》
原来45的博客
01-11 4676
本文是对于单链表的基本使用（0基础看&&超详解解读）及附上源代码，让大家初步了解链表，所以就只实现顺序表的增删查改，还有特定位置前插入和删除特定位置值等接口哈。
单链表的类定义
低调走过
07-17 6825
<br />///////////////////////////////////////////////////////////////////////////////// //通常使用两个类，即链表的结点类和链表类，协同表示单链表。 //一个链表包含了零个或多个结点，因此一个类型为List的对象包含有等于零个或多个类型 //为LinkNode的对象。这种关系在面向对象方法中叫做聚合关系，或叫做整体-局部关系。 //为简化问题，设一个单链表的每一个结点中的数据元素为一个整型数据，有4种方法设计
数据结构—链表—C++
LiuXF93的博客
10-22 2208
一、链表定义 链表是由一系列连接在一起的结点构成，其中的每个结点都是一个数据结构。 链表的结点通常是动态分配、使用和删除的，允许链表在程序运行时增大或缩小。如果需要将新信息添加到链表中，则程序只需分配另一个结点并将其插入到系列中。如果需要从链表中删除特定的信息块，则程序将删除包含该信息的结点。 二、链表的结构 2.1 单个节点的组成 链表的每个节点，除数据之外还包含一个后继指针指向链表中的下一个节点。 2.2 链表图解结构 非空链表的第一个结点称为链表的头。要访问链表中的结点，需要有一个指向链表头的指针。
链表的C++实现（线性表的链式存储C++实现）
04-05
使用C++类模板实现了线性表的链式存储结构（链表），类中包含了线性表的常用方法：向线性表中插入一个元素、删除一个元素、清空线性表、获取一个元素、获取线性表长度等。大致实现了STL中的链表的基本功能，通过对比...
数据结构实验报告2线性表的链式存储结构.pdf
09-30
本实验报告的主要内容是介绍线性表的链式存储结构，并通过编程实验来掌握线性表的逻辑结构和链式存储结构，以及单链表的基本算法。 一、线性表的概念 线性表是最基本的数据结构之一，它是由零个或多个数据元素组成...
数据结构实验报告2线性表的链式存储结构.doc
07-11
在本实验中，线性表采用链式存储结构实现，即每个元素（节点）包含一个数据域和一个指向下一个元素的指针。 链式存储结构相比于顺序存储结构（如数组），在插入和删除操作上有更高的灵活性，因为它们不需要考虑元素...
C++实现线性表链式存储（单链）
08-19
主要为大家详细介绍了C++实现线性表链式存储，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
单链表的定义(数据结构与算法)
AII_IIA的博客
10-26 1051
单链表是一种常见的数据结构，用于存储元素的序列。它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用（指针）。单链表中的节点之间通过指针连接起来，形成一个线性结构。单链表是一种简单但灵活的数据结构，常用于实现队列、堆栈和图等其他高级数据结构。
C++ 万字长文，链表详解
jinjiayang的博客
12-02 4843
C++链表详解（包括迭代器，链式存储等诸多干货）
【C++】链表的定义及其基本操作
mhyasadj的博客
01-09 1318
本文采用C++中的结构体构建链表，以及链表的一些基本操作，附带详细的解释
c++ 链表_C语言实现链表（链式存储结构）
weixin_39719165的博客
11-23 1029
链表（链式存储结构）及创建链表，别名链式存储结构或单链表，用于存储逻辑关系为 "一对一" 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。例如，使用链表存储 {1,2,3}，数据的物理存储状态如下图所示： 我们看到，上图 根本无法体现出各数据之间的逻辑关系。对此，链表的解决方案是，每个数据元素在存储时都配备一个指针，用于指向自己的直...
C++线性表的链式存储结构
BeiXi's Blog
09-20 1659
实现链表 template<class T> void LinkList<T>::Print() { LinkNode<T> *tmp = _head; while (tmp != NULL) { cout << tmp->_data << "-->"; tmp = tmp->_next; } cou...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值