数据结构与算法——线性表

最新推荐文章于 2023-10-01 22:02:14 发布
最新推荐文章于 2023-10-01 22:02:14 发布
阅读量255 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52742134/article/details/119516066
版权

目录

目录

线性表的数据类型定义

1. 顺序表

1.1 顺序表的类定义

1.2 顺序表的插入

1.3 顺序表的删除

2. 链表

2.1 单链表的节点定义

2.2 单链表的类型定义

2.3 返回指定位置pos的指针

2.4 插入单链表的第i个结点

2.5 删除单链表的第i个结点

2.6 双链表的结点定义和实现

3. 栈

3.1 栈的类定义

3.2 栈的顺序实现

3.3 栈的链式实现

4. 队列

4.1 队列的抽象数据类型定义

线性表的数据类型定义

template <class T>
class List
{
	void Clear();                                 //置空线性表
	bool IsEmpty();                               //线性表为空时，返回true
	bool Append(const T value);                   //在表尾添加元素value，表的长度增加1
	bool Insert(const int p, const T value);      //在位置p插入元素value，表的长度增加1
	bool Delete(const int p);                     //删除位置p上的元素，表的长度减少1
	bool GetValue(const int p, T& value);         //把位置p上的元素值返回到变量value中
	bool SetValue(const int p, const T value);    //把位置p上的元素至修改为value
	bool GetPos(int &p, const T value);           //把值为value的元素的位置返回到变量p中 
}

1. 顺序表

1.1 顺序表的类定义

template <class T>                                     
class ArrayList : publice List<T>                  //定义顺序表ArrayList 
{
	public:                                        //顺序表的运算集 
		ArrayList(const int size)                  //创建顺序表，表长为最大长度
		{
			maxSize = size;
			arrayList = new T[maxSize];
			curLen = 0;
			position = 0;
		} 
		
		~ArrayList()                               //析构函数，消除ArrayList的实例 
		{
			delete [] arrayList;
		} 
		
		void clear()                               //清空顺序表 
		{
			delete [] arrayList;
			curLen = 0;
			position = 0;
			arrayList = new T[maxSize];
		} 
		
		int Length();
		bool Append(const T value);                //在表尾添加元素value，表的长度增加1
		bool Insert(const int p, const T value);   //在位置p插入元素value，表的长度增加1
		bool Delete(const int p);                  //删除位置p上的元素，表的长度减少1
		bool GetValue(const int p, T& value);      //把位置p上的元素值返回到变量value中
		bool SetValue(const int p, const T value); //把位置p上的元素至修改为value
		bool GetPos(int &p, const T value);        //把值为value的元素的位置返回到变量p中 

	private:
		T *arrayList;                              //存储顺序表 
		int maxSize;                               //顺序表实例的最大长度 
		int curLen;                                //顺序表实例的当前长度
		int positon;                               //当前处理位置 
};

1.2 顺序表的插入

template <class T>
bool ArrayList<T> :: Insert(const int p, const T value)
{
	if(curLen >= maxSize)                         //检查顺序表是否溢出 
	{
		cout << "The List is overflow" << endl;
		return false;
	}
	
	if(p < 0 || p > curLen)                       //检查插入位置是否合法 
	{
		cout << "Insertion point is illegal" << endl;
	}
	
	for(int i = curLen; i > p; i--)
	{
		arrayList[i] = arrayList[i-1];
		//从表尾curLen-1处向后移动一个位置知道插入位置p 
	} 
	
	arrayList[p] = value;                         //位置p处插入新元素
	curLen++;                                     //表的实际长度增加1 
	return ture; 
}

1.3 顺序表的删除

template <class T>
bool ArrayList<T> :: Delete(const int p)
{
	if(curLen <= 0)								  //检查顺序表是否为空 
	{
		cout << "No element to delete" << endl;
		return false;
	}
	
	if(p < 0 || p > curLen - 1)					  //检查删除位置的合法性 
	{
		cout << "Deletion is illegal" <<endl;
		return false;
	}
	
	for(int i = p; i < curLen - 1; i++)
	{
		arrayList[i] = arrayList[i+1];
		//从删除位置p开始每个元素向前移动一个位置直到表尾 
	}
	curLen--;                                     //表的实际长度减1 
	return true;
}

2. 链表

2.1 单链表的节点定义

template<class T>
class LinkNode
{
	public:
		T data;                                   //数据域 
		LinkNode<T>*link;                         //指向后继指针的结点 
		LinkNode(const T&el, LinkNode<T>*ptr = 0) //构造函数 
		{                         
			data = el;
			link = ptr;
		}
};

2.2 单链表的类型定义

template<class T>
class LinkList
{
	private:
		LinkNode<T> *head, *tail;                 //表头和表尾指针 
		LinkNode<T> *prevPtr, *currPtr;           //记录表当前遍历位置的指针，由插入和删除操作更新 
		int position;                             //当前元素在表中的位置序号，由函数reset使用 
	public:
		LinkList();
		~LinkList();
		int getSize()const;                       //返回链表中的元素个数 
		bool isEmpty()const;                      //链表是否为空
		void reset(int pos = 0);                  //初始化指针的位置(第一位数的位置设为0)
		void next();                              //使指针移动到下一个结点
		bool endOfList()const;                    //指针是否到了链尾
		int currentPosition(void);                //返回指针当前的位置
		void insertHead(const T&item);            //在表头插入结点
		void insertTail(const T&item);            //在表尾添加结点 
		void insertAt(const T&item);              //在当前结点之前插入结点
		void insertAfter(const T&item);           //在当前结点之后插入结点
		T deleteHead();                           //删除头结点
		void deleteCurrent();                     //删除当前结点
		T&data();                                 //返回对当前结点成员数据的引用
		const T&data()const;                      //返回对当前结点成员数据的常引用
		void clear();                             //清空链表：释放所有结点的内存空间 
		LinkNode<T>* setPos(int pos);             //返回指定位置pos的指针 
		bool insertPos(const int i, const T value);//在指定位置插入结点 
		bool deletePos(const int i);              //删除指定位置的结点 
};

2.3 返回指定位置pos的指针

template<class T>
LinkNode<T> * LinkList<T>::setPos(int pos)
{
	if(pos == -1)                                 //i为-1则定位到头结点 
		return head;
		
	int count = 0;
	LinkNode<T> *p = head->link;
	while(p != Null && count < pos) 
	{
		p = p->link;
		count++;
	}
	return p;                                  
    //指向第i个结点，当链表长度小于1时返回NULL 
}

2.4 插入单链表的第i个结点

template<class T>
bool LinkList<T>::insertPos(const int i, const T value)
{
	LinkNode<T> *p, *q;
	if((p = setPos(i - 1)) == NULL)              //p是第i个结点的前驱 
	{
		cout << "插入操作不允许" <<endl;
		return false;
	}
	
	q = new LinkNode<T>(value, p->link);
	p->link = q;
	if(p == tail)                                //在表尾进行插入操作 
		tail = q;
	return true;
}

2.5 删除单链表的第i个结点

template<class T>
bool LinkList<T>::deletePos(const int i)
{
	LinkNode<T> *p, *q;
	if((p = setPos(i - 1)) == NULL || p == tail)//待删除点不存在 
	{
		cout << "非法删除点" <<endl;
		return false;
	}
	
	q = p->link;                               //q为真正待删除点
	if(q == tail)                              //删除点为表尾，修改为指针 
	{
		tail = p;
		p->link = NULL;
		delete q;
	}
	else if(q != NULL)                         //删除结点q，并修改指针
	{
		p->link = q->link;
		delete q;
	}
	return true; 
}

2.6 双链表的结点定义和实现

template<class T>
class DLLNode
{
	public:
		T data;                               //保存结点元素的内容 
		DLLNode<T> *next;                     //指向后继结点的指针 
		DLLNode<T> *prev;                     //指向前驱结点的指针
		
		DLLNode(const T info, DLLNode<T> *prevVal = NULL, DLLNode<T> 
		*nextVal = NULL)                      //构造函数 
		{
			data = info;
			prev = prevVal;
			next = nextVal;
		}
		DLLNode(DLLNode<T> *prevVal = NULL,DLLNode<T> *next = NULL)
		{
			prev = prevVal;
			next = nextVal;
		}
};

3. 栈

3.1 栈的类定义

template<class T>
class Stack
{
	public:
		void Clear();                         //清空栈
		bool Push(const T item);              //栈的压入操作
		bool Pop(T & item);                   //读取栈顶元素的值并删除
		bool Top(T & item);                   //读取栈顶元素的值但不删除
		bool IsEmpty();                       //判断栈是否为空
		bool IsFull();                        //判断栈是否已满 
};

3.2 栈的顺序实现

template<class T>
class ArrayStack:public Stack<T>
{
	private:
		int maxSize;                          //栈的最大值
		int top;                              //栈顶位置
		T *st;                                //存放栈元素的数组
		
	public:
		ArrayStack(int size)                  //创建一个给定长度的顺序栈实例
		{
			maxSize = size;
			top = -1;
			st = new T[maxSize]; 
		} 
		
		ArrayStack()                          //创建一个顺序栈实例 
		{
			top = -1;
		}
		 
		~ArrayStack()                         //析构函数 
		{
			delete [] st;
		}
		
		void Clear()                          //清空栈的内容 
		{
			top = -1;
		}
		
		bool Push(const T item)               //入栈操作
		{
			if(top = maxSize - 1)             //栈已满
			{
				cout << "栈满溢出" << endl;
				return false; 
			}
			else                              //入栈，并修改栈顶指针 
			{
				st[++top] = item;
				return true;
			}
		}
		
		bool Pop(T & item)                    //出栈操作
		{
			if(top == -1)                     //栈为空
			{
				cout << "栈为空，不能进行删除操作" << endl;
				return false;
			} 
			else
			{
				item  = st[top--];            //读取栈顶元素并修改栈顶指针
				return true; 
			}
		} 
		
		bool Top(T & item)                    //读取栈顶元素，但不删除 
		{
			if(top == -1)                     //栈为空
			{
				cout << "栈为空，不能读取栈顶元素" <<endl;
				return false; 
			} 
			else
			{
				item = st[top];
				return true;
			}
		}
};

3.3 栈的链式实现

template<class T>
class LinkStack:public Stack<T>
{
	private:
		LinkNode <T> *top;                    //指向栈顶的指针 
		int size;                             //存放元素的个数 
		
	public:
		LinkStack(int size)                   //构造函数 
		{
			size = 0;
			top = NULL; 
		} 
		 
		~LinkStack()                          //析构函数 
		{
			Clear();
		}
		
		void Clear()                          //清空栈的内容 
		{
			while(top != NULL)
			{
				LinkNode <T> *tmp = top;
				top = top->link;
				delete tmp;
			}
			size = 0;
		}
		
		bool Push(const T item)               //入栈操作的链式实现 
		{
			LinkNode <T> *tmp = new LinkNode<T>(item, top);
			top = tmp;
			size++;
			return true; 
		}
		
		bool Pop(T & item)                    //出栈操作的链式实现 
		{
			LinkNode<T> *tmp; 
			if(size == 0)                     //栈为空
			{
				cout << "栈为空，不能进行删除操作" << endl;
				return false;
			} 
			item = top->data;
			tmp = top->link;
			delete top;
			top = tmp;
			size--;
			return true;
		} 
		
		bool Top(T & item)                    //读取栈顶元素，但不删除 
		{
			if(size == 0)                     //栈为空
			{
				cout << "栈为空，不能读取栈顶元素" <<endl;
				return false; 
			} 
			item = top->data;
			return true;
		}
};

4. 队列

4.1 队列的抽象数据类型定义

template<class T>
class Queue
{
	public:
		void Clear();                         //清空队列 
		bool EnQueue(const T item);           //队列的尾部加入元素item 
		bool DeQueue(T & item);               //取出队列的第一个元素，并删除		
		bool IsEmpty();                       //判断队列是否为空
		bool IsFull();                        //判断队列是否已满 
		bool GetFront(T & item);              //读取队头元素，但不删除 
};

李好好先生
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构与算法——线性表 定义线性表节点的结构.pdf
04-18
【线性表】是数据结构中的基础概念，它是由n（n≥0）个相同类型元素构成的有限序列。在序列中，每个元素都有一个前驱元素和后继元素，除非是第一个元素（没有前驱）和最后一个元素（没有后继）。线性表的这种一对一...
单链表：添加、查找、删除、插入、查找倒数第k个
TheGodOfCloud的博客
11-24 441
链表的基本操作 /*1.2-a-f 链表 void createLink(); //1.2-a 以表尾添加结点的方式构建链表 int findNode(const T& value); //1.2-b 查找值为value的结点，返回第一个值为value的结点位置，若不存在返回-1 void deleteValue(const T& value);//1.2-c 删除所有值为value的结点 bool insertPos(const int i, con
【数据结构】JAVA语言实现—顺序表和单链表的基本功能（附超详细注释）
潘潘的博客
11-13 1361
文章目录1、线性表2、顺序表2.1 概念及结构2.2 顺序表接口的实现2.2.1 打印顺序表2.2.2 在pos位置新增元素2.2.3 判定是否包含某个元素2.2.4 查找某个元素对应的位置2.2.5 获取 pos 位置的元素2.2.6 给 pos 位置的元素设为 value2.2.7 删除第一次出现的关键字key2.2.8 获取顺序表长度2.2.9 清空顺序表2.3 顺序表所存在的问题及思考3、链表3.1 链表的概念及结构3.2 链表的实现3.2.1 打印链表3.2.2 头插法3.2.3 尾插法3.2.
单链表基础操作
adorable_的博客
03-17 421
单链表基础操作 1.初始化单链表 2.尾插 3.尾删 4.头插 5.头删 6.查找 7.在pos之前插入元素 8.在pos之后插入元素 9.删除指定位置的元素 10.删除指定值的元素 11.删除指定值的所有元素 12.判断链表是否为空 13.求链表元素个数
数据结构与算法 Chapter 2 线性表
dianzili1007的博客
03-03 242
2.1 线性表定义 线性表是由长度为n的一组节点组成的有限序列，其中除了首末结点之外，每个结点都有直接的前驱结点和后继结点。 2.2 线性表的顺序存储结构 顺序存储结构使用一组连续的存储单元来存储线性表。 其特点有：线性表的逻辑顺序与物理顺序一致、数据元素之间的关系采用物理位置的相邻来表示。其可以随机存取，常用一维数组表示： #include <iostream> using...
关于线性表
魏莘墨的专栏
10-01 451
线性表类模板：template class List {y void clear(); //线性表置空 bool isEmpty(); //线性表为空时，返回true bool append(const T value); //在表尾添加一个元素value，表的长度增1 bool insert(const int p, const T value); //在位置p上插入一
Educoder题目：数据结构与算法 - 线性表答案解析.md
10-18
Educoder题目：数据结构与算法 - 线性表答案解析.md
数据结构实验——线性表子系统
07-31
总结来说，这个实验不仅巩固了理论知识，还提升了实践能力，为后续更复杂的数据结构和算法学习打下了坚实的基础。通过不断地编写、调试和执行这样的程序，我们可以更深入地理解数据结构的工作原理，并能更好地应对...
数据结构实验报告——线性表.docx
11-12
在互联网领域，线性表是构建复杂数据结构和算法的基础，例如链表、数组、队列、栈等。熟练掌握线性表的操作对于软件开发和系统设计至关重要，因为它涉及到数据的存储、检索和处理效率，直接影响到程序性能。在实际...
北邮数据结构实验报告——线性表.docx
11-10
《北邮数据结构实验报告——线性表》 线性表是计算机科学中基础且重要的数据结构之一，它由相同类型的元素构成的有序序列。在这个实验中，学生被要求使用C++语言，通过循环链表来实现约瑟夫问题的求解。约瑟夫问题...
数据结构与算法之线性表
Heitao5200的博客
09-27 617
线性表 文章目录线性表线性表的定义抽象数据类型数据类型抽象抽象数据类型线性表的抽象数据类型定义顺序表顺序表的两种基本实现方式顺序表的地址计算方法顺序表的操作获得元素操作增加元素删除操作插入和删除的时间复杂度顺序表的优缺点Python中的顺序表list的基本实现技术链表头指针与头结点的异同单链表单链表存储结构节点实现单链表的操作链表是否为空链表长度遍历整个链表链表头部添加元素链表尾部添加元素指定位置...
线性表1.数组表示方法
qq_51741751的博客
02-11 783
线性表是一种线性结构。所谓线性结构是指数据元素与自然数之间存在着一对一的关系，这里的一对一并一定只得是一个数据，而是从抽象角度来说的集合，两个集合之间的元素两两相互对应。 废话不多说，上代码 #include<iostream> using namespace std; const int LIST_SIZE = 5000; class ELEM {//存储的表元素（自定义数据） private: int key; public: ELEM() { this->key = 0;
最基本的单链表C++
mmdev
09-17 116
// 单链表.cpp -- 最基本的单链表C++ // Singly-linked list node template &lt;class Elem&gt; class Link { public: Elem element; // value for this node Link *next; // pointer to next node in list Link(...
数据结构与算法系列--线性表
最新发布
2302_77343936的博客
10-01 474
针对顺序表的缺点，一种改进的思路是让相邻元素间留有足够的余地，即所有的元素都不考虑相邻的位置，哪里有空位就空到哪里，而只是让每个元素都知道它下一个元素在哪儿就可以了，这样，假设我们在表中的第一个元素，我们便知道了第二个元素的内存地址，在第二个元素，知道第三个元素的内存地址，依此类推，通过遍历的形式便可以找到所有元素的内存地址。这种思想便是线性表链式存储结构建立的前提。1.线性链表:采用链式存储结构的线性表。
数据结构与算法——线性表篇详解
♚焕蓝·未来的博客
04-24 564
线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的），因此，为了表示某个数据元素ai与它的直接后继元素ai + 1之间的逻辑关系，对数据元素ai来说，除存储其本身的信息之外，还需要存储一个指示它直接后继的信息（即直接后继的存储位置），这两部分信息组成数据元素ai的存储映像，称为结点（node）。
【数据结构与算法学习】线性表（顺序表、单链表、双向链表、循环链表）
Gefangenes的博客
06-09 1330
12345。
数据结构与算法-Part3——线性表
leikang111的博客
04-03 1379
线性表
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构实验报告——线性表、二叉树、图的实现
这篇文档是吕鹏泽同学的一份数据结构实验报告，主要探讨了基于不同存储结构的线性表、二叉树以及图的实现。以下是各部分的详细知识点： 1. 基于顺序存储结构的线性表实现 - 问题描述：使用动态分配的顺序表来实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

李好好先生

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值