常用数据结构之linklist链式线性表

最新推荐文章于 2025-03-27 10:51:42 发布
最新推荐文章于 2025-03-27 10:51:42 发布
阅读量2k 收藏
点赞数
分类专栏： 常用数据结构与算法 文章标签： 数据结构 list compiler insert null delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/freesum/article/details/7355192
版权
本文介绍了如何使用C++模板类实现链式线性表LinkList，包含头节点，支持插入和删除操作。链表的长度涵盖从a1到an的所有元素，并提供了测试用例进行验证。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 此数据结构的ADT就不说了，用链式实现线性表。实现的版本中包含一个head节点，用于指向线性表。


        链表的长度包括a1~an。

下面是用C＋＋模板类实现的一个链表方式存储的线性表linklist

/*
 * =====================================================================================
 *
 *       Filename:  3linklist.h
 *
 *    Description:  template implement of link-list
 *
 *        Version:  1.0
 *        Created:  2012年03月09日 00时44分53秒
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  Lavey Luo (lavey), luoyi.smt@gmail.com
 *   Organization:  
 *
 * =====================================================================================
 */

#ifndef __LINKLINS_H__
#define __LINKLINS_H__
#include <cstdlib>
#include <ctime>
namespace st
{
#ifndef _STATUS_CONST_
#define _STATUS_CONST_
	enum Status
	{
		OK = 0, 
		ERROR = -1
	};
#endif
	template<typename T>class linklist;
	template<class T>
		class linknode
		{
			friend class linklist<T>;
			private:
			T data;
			linknode* next;
		};

	template<class T>
		class linklist
		{
			public:
				explicit linklist(): _head(NULL){
				};
				~linklist(){ 
				};
			public:
				/* 初始化线性表 */
				Status Init();

				/* 初始条件：线性表已存在。操作结果：若L为空表，则返回OK，否则返回ERROR*/
				Status Empty();

				/* 初始条件：线性表已存在。操作结果：将L重置为空表 */
				Status Clear();

				/* 初始条件：线性表已存在。操作结果：返回L中数据元素个数 */
				int Length();

				/* 初始条件：线性表L已存在，1≤i≤ListLength(L) */
				/* 操作结果：用e返回第i个数据元素的值,注意i是指位置，第1个位置的数组是从0开始 */
				Status GetElem(int i, T& e);

				/* 初始条件：线性表L已存在 */
				/* 操作结果：返回第1个与e满足关系的数据元素的位序。 */
				/* 若这样的数据元素不存在，则返回值为ERROR */
				int Locate(const T& e);

				/* 初始条件：线性表已存在,1≤i≤ListLength(L)， */
				/* 操作结果：第i个位置之前插入新的数据元素e，长度加1 */
				Status Insert(int i,const T& e);

				/* 初始条件：线性表L已存在 */
				/* 操作结果：在顺序线性表的尾端添加一个元素，长度加1 */
				Status Pushback(const T& e);

				/* 初始条件：线性表已存在，1≤i≤ListLength(L) */
				/* 操作结果：删除的第i个数据元素，并用e返回其值，L的长度减1 */
				Status Delete(int i, T& e); 

				/*  随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
				Status CreateListHead(int n);

				/*  随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
				Status CreateListTail(int n); 
			private:
				linknode<T>* _head;	
		};

	template<class T>
		Status linklist<T>::Init()
		{ /* 产生头结点,并使L指向此头结点 */
			_head =  new linknode<T>;// malloc(sizeof(linknode));
			if(!_head) /* 存储分配失败 */
				return ERROR;
			_head->next=NULL; /* 指针域为空 */
			return OK;
		}

	template<class T>
		Status linklist<T>::Empty()
		{
			if (_head->next)
				return ERROR;
			else
				return OK;
		}

	template<class T>
		Status linklist<T>::Clear()
		{
			if (!_head->next)
				return OK;

			linknode<T>* p = _head->next;
			while(_head->next)	
			{
				_head->next =  p->next;
				delete p;
				p = _head->next;
			}
			return OK;
		}

	template<class T>
		int linklist<T>::Length()
		{
			if (!_head->next)
				return 0;
			int len = 0;
			linknode<T>* p = _head->next;
			while (p)
			{
				len++;
				p = p->next;
			}
			return len;
		}

	template<class T>
		Status linklist<T>::GetElem(int i, T& e)
		{
			if (!_head->next || i < 1)
				return ERROR;

			linknode<T>* p = _head->next;

			do {
				i--;
				p = p->next;
			} while ( i > 0 && p  );				/* -----  end do-while  ----- */
			e = p->data;
			return OK;
		}

	template<class T>
		int linklist<T>::Locate(const T& e)
		{
			if (!_head->next)
				return ERROR;

			linknode<T>* p = _head->next;
			int i = 0;

			do {
				i++;
				if (p->data == e)
					return i;
				p = p->next;
			} while ( p );				/* -----  end do-while  ----- */

			return ERROR;
		}

	template<class T>
		Status linklist<T>::Insert(int i, const T& e)
		{
			if (!_head || i < 1)
				return ERROR;

			linknode<T>* p = _head;
			int j = 1;


			while ( p && j < i  ) {
				p = p->next;
				j++;
			}
		  if (!p || j > i )
				return ERROR;

			linknode<T>* q = new linknode<T>;
			q->data = e;
			q->next = p->next;
			p->next = q;

			return OK;
		}

	template<class T>
		Status linklist<T>::Pushback(const T& e)
		{
			if (!_head->next)
				return ERROR;
			
			linknode<T> *q = new linknode<T>;
			if (!q) return ERROR;
			q->data = e;
			q->next  = NULL;
			linknode<T>* p = _head;

			while ( p->next )
			{
				p = p->next;
			}
			p->next = q;
			return OK;
		}
	template<class T>
		Status linklist<T>::Delete(int i, T& e)
		{
			if (!_head->next || i < 1)
				return ERROR;

			linknode<T>* p = _head->next;
			int j = 1;

			do {
				p = p->next;
				j++;
			} while ( p->next && j < i );				/* -----  end do-while  ----- */
			if ( !p->next ) return ERROR;
		
			linknode<T>* q = p->next;
			e = q->data;
			p->next = q->next;
			delete q;
			return OK;
		}

	template<class T>
		Status linklist<T>::CreateListHead(int n)
		{
			if (_head || n < 1) return ERROR;

			linknode<T>* p = NULL;
			int i = 0;
			srand(time(0));                         /* 初始化随机数种子 */
			_head = new linknode<T>; 
			if (!_head) return ERROR;

			_head->next = NULL;                      /*  先建立一个带头结点的单链表 */
			linknode<T>* q = _head;                      /* 表头 */
			for ( ; i < n ; i++ )
			{
				p = new linknode<T>; 
				if (!p)	return ERROR;
				p->data = rand() % 100 + i;
				p->next = q->next;
			  q->next = p; 	/*  插入到表头 */
			}
			return OK;
		}

	template<class T>
		Status linklist<T>::CreateListTail(int n)
		{
			if (_head || n < 1) return ERROR;

			linknode<T>* p = NULL;
			int i = 0;
			srand(time(0));                         /* 初始化随机数种子 */
			_head = new linknode<T>;
			if (!_head) return ERROR;
			_head->next = NULL;                      /*  先建立一个带头结点的单链表 */
			linknode<T>* q = _head;                      /* 尾表 */
			for ( ; i < n ; i++ )
			{
				p = new linknode<T>;
				if (!p)	return ERROR;
				p->data = rand() % 100 + i;
				q->next = p;
				q = p;
			}
			return OK;
		}
}
#endif //__LINKLINS_H__

还有对linklist的测试用例：

/*
 * =====================================================================================
 *
 *       Filename:  test_linklist.cpp
 *
 *    Description:  test case of the 3linklinst.h
 *
 *        Version:  1.0
 *        Created:  2012年03月11日 21时58分59秒
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  Lavey Luo (lavey), luoyi.smt@gmail.com
 *   Organization:  
 *
 * =====================================================================================
 */
#include "3linklist.h"
#include <stdio.h>

int test_linklinst (int argc,  char** argv)
{
	st::linklist<int> list1;
	list1.Init();
	if (list1.Empty() == st::OK)
		puts("the list1 is empty");
	printf(" list1 len %d\n",  list1.Length());

	puts("insert 1..5 to the list1");
	for (int i = 1; i <= 5; i++)
		list1.Insert(i,  i);
	printf(" list1 len %d\n",  list1.Length());
	
	puts("to push 200 to the end of list1");
	list1.Pushback(200);
	printf(" list1 len %d\n",  list1.Length());

	printf("locate of 200 in list1 is:%d \n", list1.Locate(200));
	printf("locate of 3 in list1 is:%d \n", list1.Locate(3));

	puts("clear the list1");
	list1.Clear();
	printf(" list1 len %d\n",  list1.Length());

	st::linklist<float> flist1;
	flist1.CreateListHead(10);
	printf(" flist1 len %d\n",  flist1.Length());

	st::linklist<float> flist2;
	flist2.CreateListTail(10);
	printf(" flist1 len %d\n",  flist2.Length());
	return 0;
}


  

数据结构---单向链表，双向链表，单向环形链表
root1994的博客
07-09 5625
链表介绍 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域:指向下一个节点. 如图:发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 修改节点功能 思路(1) 先找到该节点，通过遍历，(2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.n...
数据结构之LinkList
ryelqy的博客
08-21 1881
1、结构： 2、Link代码： public class Link { public int iData; public double dData; public Link next; public Link(int id,double dd){ iData = id; dData = dd; } public void displayLink()
数据结构——链表
最新发布
m0_70932237的博客
03-27 644
通过提供的LinkList类和其相关方法，我们可以灵活地进行节点的增、删、查等操作。链表因其动态的特性及高效的插入、删除能力，非常适用于需要频繁修改数据的数据处理场景。然而，由于链表的每个节点都需要额外维护一个指针，较传统数组而言，对于随机访问的性能较差。因此，选择链表作为数据结构时需要根据具体场景权衡利弊。
数据结构 链表 LinkList
08-02
数据结构 链表 LinkList，为大家提供一些参考
【数据结构】线性表----链表（LinkedList）
m0_47916948的博客
02-04 245
链表：处在不连续的内存空间上 链表优点：解决顺序表的搬运，增加或者删除操作## 标题 单向链表 class Node{ int val; //保存我们的元素 Node next;//保存下一个元素的引用。 } 上面为单向链表：只能从上一个节点找到下一个节点 双向链表 class Node{ int val; //保存我们的元素 Node prev;//保存上一个元素的引用。 Node next;//保存下一个元素的引用。 } 链表分类 **单向链表 vs 双链表 有
数据结构封装之《LinkList单向链表》
BeiJiaan的博客
08-28 1154
数据结构封装之《LinkList线性链表》 本人健忘，留作记录。
数据结构与算法（2）——链式线性表
cyllalala123的博客
03-24 777
线性表的链式存储结构 顺序存储结构在插入和删除时需要移动大量元素耗费时间，这是由于相邻元素存储位置具有邻居关系，内存中位置是紧挨着的，中间没有空隙就无法快速插入和删除。 链式存储结构定义： 用一组任意的存储单元存储线性表的数据元素，这组存储单元可以存在内存中未被占用的任意位置。 相比于顺序存储结构链式存储结构中除了要存储数据元素信息外，还要存储它的后继元素的存储地址（指针）。 我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称为指针或链。这两部分信息组成数据元素称为
数据结构（四） — 线性表之链式存储
dashifu11111的博客
03-26 3081
一、线性表的链式存储结构 1、线性表链式存储结构定义 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。这就意味着，这些数据元素可以存在内存未被占用的任意位置。 以前在顺序结构中，每个数据元素只需要存数据元素信息就可以了。现在链式结构中，除了要存数据元素信息外， 还要存储它的后继元素的存储地址。 因此，为了...
数据结构线性表的链式表示和实现.pdf
09-30
数据结构线性表的链式表示和实现 一、链式表示的基本概念 链式表示是一种数据结构，它使用链表来存储数据。链表是一种动态的数据结构，它由多个结点组成，每个结点包含了一个数据元素和一个指针，指向下一个结点。...
【数据结构】线性结构——线性表之链式存储结构（链表）
Jacky_Feng的博客
09-13 5283
文章目录 前言 一、链表概述 二、单链表的定义 1.定义 三、单链表的操作 前言 为了克服顺序表存储结构的缺点，充分利用存储空间和提高运行效率，线性表可以采用另一种存储结构——链式存储结构。线性表的链式存储结构简称“链表（link list）” 一、链表概述 链表的数据元素所占的存储单元地址可以是连续的，也可以是不连续的，可根据需要临时、动态地申请分配相应的存储空间，数据元素之间的逻辑关系可以用“链”来表达。 链表的插入和删除不需要移动数据元素，只需要修改链即可实现。 ..
数据结构（三）——LinkList与链表
baotu的博客
10-11 497
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
单链表LinkList
12-31
使用数据结构中的方法，实现链式存储结构，达到节省空间的目的
Java数据结构-线性表之单链表LinkedList
十六子
07-18 1337
线性表的链式存储结构，也称之为链式表，链表；链表的存储单元可以连续也可以不连续。 链表中的节点包含数据域和指针域，数据域为存储数据元素信息的域，指针域为存储直接后继位置（一般称为指针）的域。注意一个头结点和头指针的区别： 头指针： 指向链表的第一个节点的指针，若链表有头结点，则是指向头结点的指针； 头指针具有标识作用，所以常用头指针作为链表的名字； 不论链表是否为空，头指针都不为空； 是链表的必
LinkList
baidu_39458769的博客
01-07 592
linklist 可以作为双向链表，作为栈（push、pop），作为双向队列（offerFirst、offerLast、pollFirst、pollLast） //链表长度 transient int size = 0; //链表头指针 transient Node<E> first; //链表尾指针 transient Node<E> last; //构造函数...
linkList
weixin_39191862的博客
12-06 730
linkList
C语言实现的数据结构与线性表解析
"数据结构——用C描述，包含章节习题答案，涉及数据结构的基本概念、线性表的存储结构及操作等" 数据结构是计算机科学中的核心课程之一，它研究如何有效地组织和管理数据，以便进行高效的数据处理。C语言是一种常用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值