链表 讲义实现

最新推荐文章于 2024-04-28 01:00:25 发布
最新推荐文章于 2024-04-28 01:00:25 发布
阅读量146 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HdUIprince/article/details/83041579
版权
本文深入探讨了链表的数据结构，包括初始化、获取指定位置元素、插入、删除等基本操作，以及正序和逆序建表的方法。此外，还介绍了如何合并两个有序链表的高级操作，并提供了完整的源代码实现。
摘要由CSDN通过智能技术生成

在这里插入图片描述

在这里插入图片描述

链表的结构表示

template <class T>
struct Node
{
	T data;
	Node<T> *next;
	//Node(Node<T> *ptr=NULL):next(ptr){}
};

template <class T>
class LinkList
{
public:
	LinkList();
	~LinkList();
	Status PositiveCreateList(int n);	//正序建表
	Status ReverseCreateList(int n);	//逆序建表
	void Display();
	int GetLength() const;
	Status ListInsert(int i, T e);
	Status ListDelete(int i, T &e);
	Status GetElem_byID(int i, T &e);	//已知下标返回值
	Status GetElem_byKey(T key, int &i);	//已知值返回下标
	void MergeList(LinkList La, LinkList Lb);
	Status Reverse();
	Status ReverseHere();

private:
	Node<T> *head;

};

初始化操作

template <class T>
LinkList<T>::LinkList()
{
	head = new Node<T>;
	head->next = NULL;
}

获取单链表中指定位置的元素

template <class T>
Status LinkList<T>::GetElem_byID(int i, T &e)
{
	Node<T> *p;
	p = head->next;	//p指向首元节点
	int j = 1;		//初始化，p指向第一个节点，j为计数器
	while(p!=NULL && j<i)	//顺指针向后查找，直到p指向第i个元素或者为空
	{
		p = p->next;
		j++;
	}
	if(p==NULL || j>i)
	{
		return ERROR;	//第i个元素不存在
	}
	e = p->data;
	return OK;
}

在这里插入图片描述

插入操作

template <class T>
Status LinkList<T>::ListInsert(int i, T e)
{
	Node<T> *p, *s;
	p = head;
	int j = 0;
	while(p!=NULL && j<i-1)	//寻找第i-1个节点
	{
		p = p->next;
		++j;
	}
	if(p==NULL || j>i-1)
	{
		return ERROR;
	}
	s = new Node<T>;	//生成新节点
	s->data = e;
	s->next = p->next;
	p->next = s;
	return OK;
}

在这里插入图片描述

删除操作

template <class T>
Status LinkList<T>::ListDelete(int i, T &e)
{
	Node<T> *p, *q;
	p = head;
	int j = 0;
	while(p->next && j<i-1)	//寻找第i个节点，并令p指向其前趋
	{
		p = p->next;
		++j;
	}
	if(!(p->next) || j>i-1)
	{
		return ERROR;
	}
	q = p-next;
	p->next = q->next;
	e = q->data;
	delete q;
	return OK;
}

正序建表
在这里插入图片描述

template <class T>
Status LinkList<T>::PositiveCreateList(int n)
{
    Node<T> *p, *last;
    last = head;	//保留last指针
    for(int i=1; i<=n; i++)
	{
		p = new Node<T>;
		if(p == NULL)
		{
			return ERROR;
		}
		p ->data = rand();
		last->next = p;		//插到表尾
		last = p;	//last后移
	}
	last->next = NULL;
	return OK;
}

逆序建表
在这里插入图片描述

//头插法建立链表，逆位序输入n个元素的值
//建立带头结点的单链线性表
template <class T>
Status LinkList<T>::ReverseCreateList(int n)
{
	Node<T> *p;
	for(int i=n; i>0; i--)
	{
		p = new Node<T>;	//生成新节点
		if(!p)
		{
			return ERROR;
		}
		p->data = rand();		//生成一个随机数字
		p->next = head->next;
		head->next = p;		//插入到表头
	}
	return OK;
}

两个有序表的合并操作

template <class T>
void LinkList<T>::MergeList(LinkList La, LinkList Lb)
{
	Node<T> *pa, *pb, *pc, *p;
	pa = La.head->next;
	pb = Lb.head->next;
	pc = head;
	while(pa && pb)
	{
		if(pa->data >= pb->data)
		{
			p = new Node<T>;
			p->data = pa->data;
			pc->next = p;
			pc = pc->next;
			pa = pa->next;
		}
		else
		{
			p = new Node<T>;
			p->data = pb->data;
			pc->next = p;
			pc = pc->next;
			pb = pb->next;
		}
	}
	while(pa)
	{
		p = new Node<T>;
		p->data = pa->data;
		pc->next = p;
		pc = pc->next;
		pa = pa->next;
	}
	while(pb)
	{
		p = new Node<T>;
		p->data = pb->data;
		pc->next = p;
		pc = pc->next;
		pb = pb->next;
	}
}

完整源码

#include <iostream>
#include <cstdlib>
using namespace std;

const int OK = 1;
const int ERROR = 0;

typedef int Status;

template <class T>
struct Node
{
	T data;
	Node<T> *next;
	//Node(Node<T> *ptr=NULL):next(ptr){}
};

template <class T>
class LinkList
{
public:
	LinkList();
	~LinkList();
	Status PositiveCreateList(int n);	//正序建表
	Status ReverseCreateList(int n);	//逆序建表
	void Display();
	int GetLength() const;
	Status ListInsert(int i, T e);
	Status ListDelete(int i, T &e);
	Status GetElem_byID(int i, T &e);	//已知下标返回值
	Status GetElem_byKey(T key, int &i);	//已知值返回下标
	void MergeList(LinkList La, LinkList Lb);
	Status Reverse();
	Status ReverseHere();

private:
	Node<T> *head;

};

template <class T>
LinkList<T>::LinkList()
{
	head = new Node<T>;
	head->next = NULL;
}

template <class T>
LinkList<T>::~LinkList()
{
	Node<T> *p = head;
	while(p!=NULL)
	{
		head = head->next;
		delete p;
		p = head;
	}
}

template <class T>
Status LinkList<T>::GetElem_byID(int i, T &e)
{
	Node<T> *p;
	p = head->next;	//p指向首元节点
	int j = 1;		//初始化，p指向第一个节点，j为计数器
	while(p!=NULL && j<i)	//顺指针向后查找，直到p指向第i个元素或者为空
	{
		p = p->next;
		j++;
	}
	if(p==NULL || j>i)
	{
		return ERROR;	//第i个元素不存在
	}
	e = p->data;
	return OK;
}

template <class T>
Status LinkList<T>::GetElem_byKey(T key, int &i)
{
	i = 0;
	Node<T> *p = head->next;
	if(p == NULL)
	{
		return ERROR;
	}
	while(p != NULL)
	{
		++i;
		if(p->data == key)
		{
			return OK;
		}
		p = p->next;
	}
	return ERROR;
}


template <class T>
Status LinkList<T>::ListInsert(int i, T e)
{
	Node<T> *p, *s;
	p = head;
	int j = 0;
	while(p!=NULL && j<i-1)	//寻找第i-1个节点
	{
		p = p->next;
		++j;
	}
	if(p==NULL || j>i-1)
	{
		return ERROR;
	}
	s = new Node<T>;	//生成新节点
	s->data = e;
	s->next = p->next;
	p->next = s;
	return OK;
}


template <class T>
Status LinkList<T>::ListDelete(int i, T &e)
{
	Node<T> *p, *q;
	p = head;
	int j = 0;
	while(p->next && j<i-1)	//寻找第i个节点，并令p指向其前趋
	{
		p = p->next;
		++j;
	}
	if(!(p->next) || j>i-1)
	{
		return ERROR;
	}
	q = p->next;
	p->next = q->next;
	e = q->data;
	delete q;
	return OK;
}

template <class T>
void LinkList<T>::Display()
{
	Node<T> *p = head->next;
	while(p!=NULL)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}

template <class T>
int LinkList<T>::GetLength() const
{
	Node<T> *p = head->next;
	int cnt = 0;
	while(p != NULL)
	{
		cnt++;
		p = p->next;
	}
	return cnt;
}

template <class T>
Status LinkList<T>::PositiveCreateList(int n)
{
    Node<T> *p, *last;
    last = head;	//保留last指针
    for(int i=1; i<=n; i++)
	{
		p = new Node<T>;
		if(p == NULL)
		{
			return ERROR;
		}
		p ->data = rand();
		last->next = p;		//插到表尾
		last = p;	//last后移
	}
	last->next = NULL;
	return OK;
}

//头插法建立链表，逆位序输入n个元素的值
//建立带头结点的单链线性表
template <class T>
Status LinkList<T>::ReverseCreateList(int n)
{
	Node<T> *p;
	for(int i=n; i>0; i--)
	{
		p = new Node<T>;	//生成新节点
		if(!p)
		{
			return ERROR;
		}
		p->data = rand();		//生成一个随机数字
		p->next = head->next;
		head->next = p;		//插入到表头
	}
	return OK;
}

template <class T>
void LinkList<T>::MergeList(LinkList La, LinkList Lb)
{
	Node<T> *pa, *pb, *pc, *p;
	pa = La.head->next;
	pb = Lb.head->next;
	pc = head;
	while(pa && pb)
	{
		if(pa->data >= pb->data)
		{
			p = new Node<T>;
			p->data = pa->data;
			pc->next = p;
			pc = pc->next;
			pa = pa->next;
		}
		else
		{
			p = new Node<T>;
			p->data = pb->data;
			pc->next = p;
			pc = pc->next;
			pb = pb->next;
		}
	}
	while(pa)
	{
		p = new Node<T>;
		p->data = pa->data;
		pc->next = p;
		pc = pc->next;
		pa = pa->next;
	}
	while(pb)
	{
		p = new Node<T>;
		p->data = pb->data;
		pc->next = p;
		pc = pc->next;
		pb = pb->next;
	}
	pc->next = NULL;
}

//新开辟空间的反转
template <class T>
Status LinkList<T>::Reverse()
{
	Node<T> *p = head->next;
	Node<T> *q = p;
	if(p == NULL)
		return ERROR;
	bool flag = false;
	while(p != NULL)
	{
		Node<T> *s = new Node<T>;
		s->next = NULL;
		s->data = p->data;
		p = p->next;
		delete q;	//逐个释放节点
		q = p;
		if(flag)
		{
			s->next = head->next;
		}
		else
		{
			flag = true;
		}

		head->next = s;
	}

	return OK;
}

//就地反转
template<class T>
Status LinkList<T>::ReverseHere()
{
	if(head->next == NULL)
	{
		return ERROR;
	}
	if(head->next->next == NULL)
	{
		return OK;
	}
	Node<T> *p = head->next->next;
	head->next->next = NULL;
	Node<T> *q = p->next;
	while(p != NULL)
	{
		p->next = head->next;
		head->next = p;
		p = q;
		if(q != NULL)
		{
			q = q->next;
		}
	}
	return OK;
}

int main()
{
	LinkList<int> list1;
	list1.PositiveCreateList(10);
	cout << "List1 : ";
	list1.Display();
	cout << "List1的长度为：";
	cout << list1.GetLength()<<endl;
	int temp = 0;
	list1.GetElem_byID(4, temp);
	cout << "List1中第4个元素是: " <<temp<<endl;
	int i=0;
	list1.GetElem_byKey(15724, i);
	cout << "List1中值为15724的元素在第"<< i << "个位置"<<endl;

	cout << "在List1中第3个位置插入值23456"<<endl;
	list1.ListInsert(3, 23456);
	list1.Display();
	cout << "删除该元素";
	list1.ListDelete(3, temp);
	list1.Display();



	LinkList<int> list2;
	list2.ReverseCreateList(10);
	cout << "List2 : ";
	list2.Display();

	LinkList<int> list3, list4, list5;
	for(int i=1; i<=10; i++)
	{
		list4.ListInsert(1, 2*i-1);
		list5.ListInsert(1, 2*i);
	}
	cout << "List4, List5如下："<<endl;
	list4.Display();
	list5.Display();
	list3.MergeList(list4, list5);
	cout << "合并后的list3为："<<endl;
	list3.Display();

	cout << "反转操作："<<endl;

	cout << "L2新开辟空间的反转:";
	list2.Reverse();
	list2.Display();

	cout << "List1就地反转：";
	list1.ReverseHere();
	list1.Display();

	return 0;
}

结果如下：
在这里插入图片描述

liuxiaocs7
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入学习链表实现原理
m0_69526738的博客
04-24 109
[](()getSize()方法 getSize()方法返回结点数量，在属性中定义了一个结点数量的属性size，所以这里直接返回size属性即可。 public Integer getSize(){ return size; } [](()isEmpty()方法 isEmpty()方法判断链表是否为空，如果size结点的数量等于0即链表为空。 public Boolean isEmpty(){ return size == 0; } [](()traverse()方法 traverse()方法遍历链表中的所
链表详解
上好佳的博客
06-22 887
链表概念：    链表其实是一段有先后连接顺序的元素连接形成的数据结构；链表组成：    当前元素的指针，当前元素数值，当前元素的下一指针指向；对于java而言，没有引入C的指针，那么对应java就变成了当前元素的内存地址，当前元素的值，下一元素的内存地址链表Node对象：private static class Node&lt;E&gt; { 2 E item; 3 ...
C语言讲义——链表的实现
weixin_30569153的博客
07-15 90
节点（结构体描述） struct Node { int _id; char s[50]; struct Node* pre;// 指向前一个节点的地址 struct Node* next;// 指向下一个节点的地址 }; 新建节点（开辟内存空间） 参数： 为新节点id字段赋值 返回值：新节点的地址（指针） struct Node* node_new(int id)...
链表详细解析
qq_63137068的博客
04-09 365
hello，小伙伴们，大家好，本期讲解的是关于基础链表创建和应用 所谓链表其实是指针和结构体组成的一种链式数组，那么链表的作用是什么呢，链表的作用是用来插入数的（注意这点，是插入数而不是覆盖整），之前做过关于插入数组的题，当时是用两个数组，用第二个数组一直来覆盖第一个数组写的，但是明显效率不高而且很烂的感觉。
[数据结构] 链表(图文超详解讲解)
积跬步以至千里
09-30 3207
根据本文对链表的介绍后大家能对链表有更深的理解相信大家在过后时间能够保持求学的态度,我们一起加油!offer拿到手软!对博主感兴趣可以关注博主,我会继续更新博客,努力完善我的文章内容不会辜负大家的期待!
链式栈的实现
qq_45830912的博客
03-02 187
链式栈的实现 链式栈通过LinkNode结构体来实现，和链式表类似。 链式栈和顺序栈一样，也遵循FILO原则。 LinkedStack.h 头文件 //LinkedStack.h #include <iostream> #include <assert.h> using namespace std; template <class T> struct LinkNode { T data; LinkNode<T>* link; LinkNode(Link
C语言链表逆转方法,c语言单向链表逆转实现方法
weixin_39826971的博客
05-21 267
自己理解的思路如下所示：从第二个节点开始，先记录下一个节点，把第二个节点移到头节点之前，头节点变为移动的这个节点之前记录的节点变为接下来要移动的节点用for循环重复最后把原来头节点变成尾节点(*next指向NULL)返回链表 的头节点c语言实现代码如下：struct stu *reserve(struct stu *head){struct stu *p1,*p2,*p3;p1=head;p2=p...
Java数据结构——代码实现双向链表的方法_java实现双向链表
最新发布
2401_84181524的博客
04-28 323
在删除一个key的基础上，如果无论cur节点的值等不等于key，都向后走，直到链表结束，遇见值为key的节点就删除，就能完成删除所有key节点。只需要删除return这行代码，cur就能一直向后走，完成所有key节点的删除。
双向链表（JavaScript实现）
2301_79099606的博客
04-22 808
javascript是前端必要掌握的真正算得上是编程语言的语言，学会灵活运用javascript，将对以后学习工作有非常大的帮助。掌握它最重要的首先是学习好基础知识，而后通过不断的实战来提升我们的编程技巧和逻辑思维。这一块学习是持续的，直到我们真正掌握它并且能够灵活运用它。如果最开始学习一两遍之后，发现暂时没有提升的空间，我们可以暂时放一放。继续下面的学习，javascript贯穿我们前端工作中，在之后的学习实现里也会遇到和锻炼到。真正学习起来并不难理解，关键是灵活运用。
基于C++的机房预约系统大作业实现代码和讲义
02-15
【标题】"基于C++的机房预约系统大作业实现代码和讲义"涉及的核心知识点主要围绕C++编程语言和机房预约系统的开发。在这个项目中，学生或开发者需要运用C++来构建一个完整的机房预约系统，这涉及到对C++语言的深入...
数据结构基础讲义
09-27
在“数据结构基础讲义”中，我们将会深入探讨一系列关键的数据结构及其应用，包括链表、队列、堆栈、树以及图等。 首先，链表是一种线性数据结构，不同于数组，它不连续存储数据。每个元素称为节点，包含数据和指向...
数据结构-课件-算法实现-讲义-严蔚敏
08-23
讲义通常会包含每种数据结构和算法的定义、特性、操作以及适用场景，还会通过实例和伪代码来解释其工作原理。复习重点可能涵盖了这些知识点的关键点，帮助学生巩固和准备考试。 严蔚敏教授的数据结构课件以其清晰的...
数据结构手把手教学——单向链表
Sanjay_Wu的博客
12-03 1010
文章不空谈理论，完全采用手把手教学，并有综合示例练习题，看完这篇，你绝对能掌握数据结构单向链表。
DFS时间复杂度
热门推荐
liuxiaocs7的博客
04-06 2万+
DFS算法是一一个递归算法，需要借助一个递归工作栈，故它的空间复杂度为O(N)O(N)O(N)。 遍历图的过程实质上是对每个顶点查找其邻接点的过程，其耗费的时间取决于所采用结构。 邻接表表示时，查找所有顶点的邻接点所需时间为O(E)O(E)O(E)，访问顶点的邻接点所花时间为O(N)O(N)O(N),此时，总的时间复杂度为O(N+E)O(N+E)O(N+E)。 邻接矩阵表示时，查找每个顶点的邻接...
BFS时间复杂度
liuxiaocs7的博客
04-10 1万+
BFS是一种借助队列来存储的过程，分层查找，优先考虑距离出发点近的点。无论是在邻接表还是邻接矩阵中存储，都需要借助一个辅助队列，N个顶点均需入队，最坏的情况下，空间复杂度为O(N)O(N)O(N)。 邻接表形式存储时，每个顶点均需搜索一次，时间复杂度T1=O(N)T1=O(N)T1=O(N)，从一个顶点开始搜索时，开始搜索，访问未被访问过的节点。最坏的情况下，每个顶点至少访问一次，每条边至少访问...
邻接表遍历的时间复杂度
liuxiaocs7的博客
04-06 1万+
如果是无向图，则遍历时先访问顶点数组的各个元素，再访问其对应的边链表，由于有NNN个节点，而且无向图的EEE条边在边链表中会出现两次共为2E2E2E次，故一共的访问次数为N+2EN+2EN+2E 如果是有向图，则其EEE条边在边链表中不会出现两次(因为此时边链表值代表出度或者入度)，共总共的访问次数为N+EN+EN+E次，故时间复杂性为O(N+E)O(N+E)O(N+E) ...
邻接矩阵和邻接表空间问题
liuxiaocs7的博客
04-06 4258
设有NNN个个节点，使用邻接矩阵存储时，顶点数组占NNN块空间，而邻接矩阵占N2N^2N2块空间。故使用邻接矩阵所需要的总空间为N+N2N + N^2N+N2 在使用邻接表的时候，顶点数组中同时有数据域和指针域，占用2N2N2N空间，边节点假设有2E2E2E个(每条边都会出现两次)，每个边节点有存储节点序号的数据域和指向下一个节点的指针域共占用4E4E4E块空间。故使用邻接矩阵所需要的总空间为2...
数据结构 实验二 栈和队列的应用
liuxiaocs7的博客
10-12 1485
参考文献 #include &amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;gt; using namespace std; const int ERROR = 0; const int OK = 1; const int EMPTY = 1; typedef int Status; template &amp;amp;amp;amp;lt;class T&amp;amp;amp;amp;gt; struct Node {
数据结构 实验一 线性表的应用
liuxiaocs7的博客
10-06 715
#include &amp;lt;iostream&amp;gt; using namespace std; const int MAXSIZE = 20; const int ERROR = 0; const int OK = 1; typedef int Status; //顺序表实现 //template &amp;lt;typename T&amp;gt; typedef struct Student { i...
清华大学数据结构讲义：二叉树的二叉链表存储实现详解
在清华大学的数据结构讲义中，重点探讨了二叉树的二叉链表存储表示方法。二叉树是一种常用的数据结构，它的节点包含两个指向子节点的指针，一个左孩子(lchild)和一个右孩子(rchild)。在编程中，`BiTNode` 结构体被...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值