C++实现数据结构之线性表、栈和队列

最新推荐文章于 2023-08-24 18:06:30 发布
最新推荐文章于 2023-08-24 18:06:30 发布
阅读量1.1k 收藏 12
点赞数 2
文章标签： 数据结构 队列 链表 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25987429/article/details/108781828
版权

三种基本的数据结构

前言

接触csdn的第一篇博客，用来记录对数据结构与算法这门课的所学与收获。同时也是第一次尝试Markdown编辑。

ADT

抽象数据类型（Abstract Data Type，ADT）

通常是对数据的某种抽象，定义了数据的取值范围及其结构形式，以及对数据操作的集合

特征

1.数据抽象
2.数据封装
3.继承性
4.多态性

在接下来的具体实现中，所有的顺序实现与链式实现的类将继承自一个拥有许多纯虚函数的抽象类，例如AStack（顺序栈）与LStack（链式栈）继承自Stack类，此处以Stack为例：

template<typename>
class Stack
{
private:
	void operator =(const Stack&)() //复制运算符重载
	Stack(const Stack&){} //复制构造函数
public:
	Stack() {} 
	virtual ~Stack() {}
	virtual void clear() = 0;
	virtual void push(const E& it) = 0;
	virtual E pop() = 0;
	virtual const E& topValue()const = 0;
	virtual int length()const = 0;
};

可以看到，类中所含函数多有virtual。

C++的隐藏规则：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。
即virtual的目的：使子类中同名同参数函数可继承基类不被隐藏

虚函数与纯虚函数的区别在于是否限定函数值 = 0

虚函数在子类中可以被override(覆盖)、overload (重载 )
拥有纯虚函数的类称为抽象类,抽象类不能被实例化.
纯虚函数被继承后为虚函数
纯虚函数在类（父类）中只提供声明，不提供实现，实现由子类去完成

结点类

顺序结构中一般以数组为基础
而链式结构中以结点为基础
结点是包含一个元素和指向下一个结点的指针的类

template <typename E> class Link
{
public:
    E element;      // 结点对应的值
    Link* next;        // 指向下一个结点的指针

    Link(const E& elemval, Link* nextval = NULL)
    {
        element = elemval;  next = nextval;
    }
    Link(Link* nextval = NULL) { next = nextval; }
};

线性表

由元素组成的有限且有序的数列
关键设计：对当前位置（curr）的支持

ADT：

template <typename E>
class List
{
private:
	void operator = (const List&){}
	List(const List&){}
public:
	List(){}
	virtual ~List(){}
	virtual void clear() = 0;
	virtual void insert(const E& item) = 0; //在当前位置插入
	virtual void append(const E& item) = 0; //在末尾插入
	virtual E remove() = 0;
	virtual void moveToStart() = 0; //以下五个方法为对栅栏（curr）的移动
	virtual void moveToEnd() = 0;
	virtual void prev() = 0;
	virtual void next() = 0;
	virtual void moveToPos(int pos) = 0;
	virtual int length() const = 0;
	virtual int currPos()const = 0; 
	virtual const E& getValue()const = 0;
};

表的遍历方法：

for (L.moveToStart(); L.currPos() < L.length(); L.next())
    {
        it = L.getValue();
        dosomething(it); //自定义的对获取值的操作
    }

A.顺序实现

顺序表基于数组，与数组的操作大致相同，除了插入和删除的时间复杂度为n外，其余均为常数级，但正是由于插入和删除操作需要移动当前位置以右的左右元素，较为麻烦，故而有链式实现

子类新增的私有成员：

private:
	int maxSize;
	int listSize;
	int curr;
	E* listArray;

公有的成员函数实现

public:

	AList(int size = 10)
	{
		maxSize = size;
		listSize = curr = 0;
		listArray = new E[maxSize];
	}

	~AList()
	{
		delete[] listArray;
	}

	void clear()
	{
		delete[] listArray;
		listSize = curr = 0;
		listArray = new E[maxSize];
	}

	void insert(const E& it)
	{
		assert(listSize < maxSize);
		for (int i = listSize; i > curr; i--)
		{
			listArray[i] = listArray[i - 1];
		}
		listArray[curr] = it;
		listSize++;
	}

	void append(const E& it)
	{
		assert(listSize < maxSize);
		listArray[listSize++] = it;
	}

	E remove()
	{
		assert((curr >= 0) && (curr < listSize));
		E it = listArray[curr];
		for (int i = curr; i < listSize - 1; i++)
		{
			listArray[i] = listArray[i + 1];
		}
		listSize--;
		return it;
	}

	void moveToStart() { curr = 0; }
	void moveToEnd() { curr = listSize; }
	void prev() { if (curr > 0)curr--; }
	void next() { if (curr < listSize)curr++; }

	int length() const { return listSize; }
	int currPos() const { return curr; }

	void moveToPos(int pos)
	{
		assert((pos >= 0) && (pos <= listSize));
		curr = pos;
	}

	const E& getValue() const
	{
		assert((curr >= 0) && (curr < listSize));
		return listArray[curr];
	}

B.链式实现

链表以结点为依托，如下图，每一个结点包含一个元素与指向下一个结点的指针
head 指向一个不储存值的头部结点
tail 指向最后一个储存值的结点
curr 指向当前结点的下一个结点
若curr = head，则指向的元素为20
若curr = tail，则指向空结点

链表实现的图示

子类新增的私有成员：

private:
	Link<E>* head; // 指向表头的指针
	Link<E>* tail; // 指向表尾的指针
	Link<E>* curr; // 指向当前位置的指针
	int cnt;       // 表长
	// 初始化
	void init()
	{
		curr = tail = head = new Link<E>;
		cnt = 0;
	}

	// 清除表
	void removeall()
	{
		while (head != NULL)
		{
			curr = head;
			head = head->next;
			delete curr;
		}
	}

成员函数实现：

public:
	Llist(int size = 10) { init(); }
	~Llist() { removeall(); }
	void clear() { removeall(); init(); }
	void insert(const E& it)
	{
		curr->next = new Link<E>(it, curr->next);
		if (tail == curr)tail = curr->next;
		cnt++;
	}
	void append(const E& it)
	{
		tail->next = new Link<E>(it, NULL);
		tail = tail->next;
		cnt++;
	}

	E remove()
	{
		assert(curr->next != NULL);
		E it = curr->next->element;
		Link<E>* itemp = curr->next;
		if (tail == curr->next)tail = curr;
		curr->next = curr->next->next;
		delete itemp;
		cnt--;
		return it;
	}

	void moveToStart()
	{
		curr = head;
	}

	void moveToEnd()
	{
		curr = tail;
	}

	//单向链表所有结点指向下一元素，故其prev方法较复杂
	//可以通过双链表来解决该问题
	void prev()
	{
		if (head == curr)return;
		Link<E>* itemp = head;
		while (itemp->next != curr)
		{
			itemp = itemp->next;
		}
		curr = itemp;
	}

	void next()
	{
		if (curr == tail)return;
		curr = curr->next;
	}

	int  length() const
	{
		return cnt;
	}

	int currPos() const
	{
		Link<E>* itemp = head;
		int m_currpos = 0;
		while (itemp != curr)
		{
			itemp = itemp->next;
			m_currpos++;
		}
		return m_currpos;
	}

	void moveToPos(int pos)
	{
		assert((pos >= 0) && (pos <= cnt));
		curr = head;
		for (int i = 0; i < pos; i++)
		{
			curr = curr->next;
		}
	}

	const E& getValue()const
	{
		assert(curr != tail);
		return curr->next->element;
	}

栈

限定仅在一端进行插入或删除操作的线性表

ADT：

template<typename>
class Stack
{
private:
	void operator =(const Stack&)()
	Stack(const Stack&){}
public:
	Stack() {}
	virtual ~Stack() {}
	virtual void clear() = 0;
	virtual void push(const E& it) = 0;
	virtual E pop() = 0;
	virtual const E& topValue()const = 0;
	virtual int length()const = 0;
};

顺序实现

本质上是顺序表实现的简化
可以在一个数组中储存两个栈（双向）
初始长度固定，空间浪费

子类新增的私有成员：

private:
	int maxSize;
	int top;
	E* listArray;

成员函数的实现：

AStack(int size = 10)
	{
		maxSize = size;
		top = 0;
		listArray = new E[size];
	}
	~AStack()
	{
		delete [] listArray;
	}
	void clear()
	{
		top = 0;
	}
	void push(const E& it)
	{
		assert(top != maxSize);
		listArray[top++] = it;
	}
	E pop()
	{
		assert(top != 0);
		return listArray[--top];
	}
	const E& topValue()const
	{
		assert(top != 0);
		return listArray[top-1];
	}
	int length()const
	{
		return top;
	}

链式实现

长度可变
每个元素需要一个链接域，结构性开销

新增的私有成员：

private:
	Link<E>* top;
	int size;

成员函数实现:

public:
	LStack()
	{
		top = NULL;
		size = 0;
	}
	~LStack()
	{
		clear();
	}
	void clear()
	{
		while (top != NULL)
		{
			Link<E>* temp = top;
			top = top->next;
			delete temp;
		}
		size = 0;
	}
	void push(const E& it)
	{
		top = new Link<E>(it, top);
		size++;
	}
	E pop()
	{
		assert(top != NULL);
		E it = top->element;
		Link<E>* itemp = top->next;
		delete top;
		top = itemp;
		size--;
		return it;
	}
	const E& topValue()const
	{
		assert(top != NULL);
		return top->element;
	}

	int length()const
	{
		return size;
	}

队列

一种受限制的线性表：
队列元素只能从队尾插入（rear），队首删除（front）

ADT:

template<typename E>
class Queue
{
private:
	void operator = (const Queue&){}
	Queue(const Queue&){}
public:
	Queue(){}
	virtual ~Queue() {}
	virtual void clear() = 0;
	virtual void enqueue(const E&) = 0;
	virtual E dequeue() = 0;
	virtual const E& frontValue()const = 0;
	virtual int length()const = 0;
};

顺序实现

front永远标识头部元素，rear永远标识尾部元素
取模操作：
可将数组转换成一个首尾相连的循环数组
在初始的最大长度上+1：
使数组元素不被存满，用于区分空队列与满队列
若数组元素存满，则此时rear与front的状态与空队列相同

新增的私有成员：

private:
	int maxSize;
	int front;
	int rear;
	E* listArray;

成员函数实现:

public:

	Aqueue(int size = 10)
	{
		maxsize = size++;
		rear = 0;
		front = 1;
		listArray = new E[maxSize];
	}

	~AQueue() { delete[] listArray; }

	void clear() { rear = 0; front = 1; }

	void enqueue(const E& it)
	{
		assert(((rear + 2) % maxSize) != front);
		rear = (rear + 1) % maxSize;
		listArray[rear] = it;
	}

	E dequeue()
	{
		assert(length() != 0);
		E it = listArray[front];
		front = (front + 1) % maxSize;
		return it;
	}

	const E& frontValue() const
	{
		assert(length() != 0);
		return listArray[front];
	}

	virtual int length()const
	{
		return (((rear + maxSize) - front + 1) % maxSize);
	}

链式实现

链表的简单化
且在空间上与顺序实现的差异与栈类似，故不过多赘述

新增的私有成员：

private:
	Link<E>* front;
	Link<E>* rear;
	int size;

成员函数实现:

public:
	Lqueue(int sz = 10)
	{
		front = rear = new Link<E>();
		size = 0;
	}

	~Lqueue() { clear(); delete front; }
	
	void clear()
	{
		Link<E>* itemp;
		while (front != NULL)
		{
			itemp = front;
			front = front->next;
			delete itemp;
		}
		front = rear = new Link<E>();
		size = 0;
	}

	void enqueue(const E& it)
	{
		rear->next = new Link<E>(it, NULL);
		rear = rear->next;
		size++;
	}

	E dequeue()
	{
		assert(size != 0);
		E it = front->next->element;
		Link<E>* itemp = front->next;
		front->next = itemp->next;
		if (rear == itemp)rear = front;
		delete itemp;
		size--;
		return it;
	}

	const E& frontValue()const
	{
		assert(size != 0);
		return front->next->element;
	}

	virtual int length() const { return size; }
SayColorfully
关注
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
C++单链表简单实现栈和队列(继承和派生)
weixin_41524006的博客
03-21 329
C++单链表简单实现栈和队列(继承和派生)
面向对象程序设计C++——利用链表实现栈和队列（继承）
ChristensonLee的博客
05-08 1743
**【问题描述】**利用链表实现栈和队列 队列具有先进先出的特点，所有新来的元素都放在队列尾部，出队列的元素从队列头部出去。下面是队列的示意图： 栈具有后进先出的特点。所有入栈的元素都放在栈顶，出栈时栈顶元素先出。下面是栈的示意图： 这两种结构具有很多相似的地方：都存放了一系列的元素，元素的操作都在两头进行，元素个数都是动态可变的。我们可以设计一个基类，完成它们共同的功能，然后分别派生出队列类和栈类。本实验要求以上一个实验实现的链表类作为基类并设计它的两个派生类。 要求： (1) 在上一个实验实现的链表
第一章 绪论
williananjhon的博客
05-22 227
第一章 绪论 一 数据结构基本概念 1 数据 数据是信息的载体，是描述客观事物属性的数、字符以及所有能够输入到计算机中并被计算机程序识别和处理的符合的集合 2 数据元素 数据元素是数据的基本单位，通常作为一个整体进行考虑和处理。一个数据元素可由若干个数据项组成，数据项是构造数据元素的不可分割的最小单位。 3 数据类型 数据类型是一个值的集合和定义在此集合上一组操作的总称。 原子类型：其值不可再...
数据结构程序模板（图、栈、队列、链表、二叉树），C语言/C++
weixin_54730871的博客
08-24 1111
这次就上岸吧
栈和队列基于线性表简单实现
qq_55895496的博客
09-20 291
栈: 是一种特殊的线性表，后进先出，只能在顶部进行入栈出栈操作，可以用顺序表实现，也可以链表实现，这里用顺序表实现，下面的队列采用链表实现。队列：也是有限制的线性表，先进先出，就像做核酸是排的队，先入队的也最先出队。注：队尾是指进入队伍的那一边。
数据结构中线性表，队列和栈
01-07
线性表、栈和队列是数据结构中的基本概念，它们在编程中有着广泛的应用。 1. 线性表： 线性表是一种最简单、最基本的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。这些元素可以按顺序存储，如数组，也...
c++ 数据结构 教程 线性表 栈 队列 串
10-20
总的来说，C++数据结构的学习是编程者进阶的必经之路，通过学习线性表、栈、队列和串，你可以更好地理解如何优化算法，提高程序效率，并为解决更复杂的问题打下坚实的基础。无论是初学者还是经验丰富的开发者，持续...
数据结构不挂科-3-栈和队列.pdf
07-17
然而，标准库通常不直接提供栈和队列的数据结构，开发者需要自行实现或利用现有的库函数，如在C++标准模板库（STL）中，`stack`和`queue`容器已经封装好。 ### 例题解析 关于栈的应用，例如例题3-1中描述了一个...
利用C++实现以下经典数据结构算法：线性表、栈、队列、数组（特殊矩阵、稀疏矩阵压缩）、串（朴素模式匹配、KMP算法）、树.zip
最新发布
12-28
利用C++实现以下经典数据结构与算法：线性表（顺序表、链表、静态链表、三元组）、栈（双栈、共享栈）、队列（任务调度、循环队列、双向队列、链队列）、数组（特殊矩阵、稀疏矩阵压缩）、串（朴素模式匹配、KMP算法...
关于利用数组实现线性表,栈以及队列
qq_43606370的博客
09-19 262
【代码】关于利用数组实现线性表,栈以及队列。
数据结构-线性表之用队列实现栈&&用栈实现队列
快乐江湖的博客
01-27 1469
文章目录一：思路二：实现（1）结构体定义（2）初始化和销毁（3）进“栈”（4）出“栈”三：代码 一：思路 二：实现 （1）结构体定义 （2）初始化和销毁 注意：在测试文件外新建一个Mystack结构体时，不能只有一句Mystack ms，因为使用队列实现栈，那么该栈的底层是队列，所以必须同时要创建队列结构体，然后进行赋值才可以 （3）进“栈” 注意：进栈和出栈本质是在操作队列，所以这里仅仅使用的队列操作的接口，如果想要了解队列的出队和入队操作，请看： 数据结构-线性表之栈和队列 （4）出“栈
线性表-栈和队列
kk阿彬
10-15 359
文章目录栈队列循环队列队列常见应用场景 栈 栈是只允许在有序的线性数据集合的一端进行加入和移除数据的线性表。 数据时后进先出 队列是允许在有序的线性数据集合的两端进行加入和移除数据的线性表，数据时先进先出( FIFO，First In, First Out)。 栈的常见应用场景 实现浏览器的回退和前进功能，需要两个栈 检查括号是否成对出现， 思想：从左往右依次扫描，“（” 进，“）” 取栈顶元素进行判断 反转字符串：将字符串中的每个字符先入栈再出栈就可以了。 维护函数调用：最后
问题 A: 算法3-7：银行排队
weixin_51988154的博客
07-02 1595
时间限制:1 Sec内存限制:32 MB 提交:751解决:509 题目描述 我们大多都有在银行排队的经历，唉，那坑爹的排队啊！现在就让我们来算算我们这些客户平均需要等多久吧。 每天刚开始时银行会开m个窗口来为我们total个客户办理业务，当有客户需要办理业务时，先选择可以办理业务的窗口，如果有多个窗口可以办理业务就选择空闲时间最长的窗口，如果有多个窗口空闲的时间一样长，则选择序号小的窗口办理业务。假设我们每个人来到的时间和办理业务所需要的时间（为了简化问题，采用整数表示时间）都知道...
数据结构学习2——栈和队列（通过C++代码例子）
m0_53552112的博客
07-31 763
本篇博客是通过c++实现栈和队列的两个实验小例子。判断回文数和停车场收费问题
用实例讲解栈和队列（C++）
DjangoBUAA的博客
04-23 2715
一、栈和队列 1、实现一个新型的栈结构，具有pop、push、top、size和getMin操作。 解法：用两个普通栈实现。 class Solution { public:     stackint> data,minData;     void push(int value) {         data.push(value);
栈和队列的C++实现
weixin_36670529的博客
04-28 973
线性表中，先进先出的叫队列，先进后出的叫栈。队列常用于BFS，而在函数递归层数过高时，需要手动实现递归过程，这时候便需要写一个“手动栈”。 有时候，我们会有大量数据频繁出入队列，但同时存在其内的元素却不多，此时需要写“循环队列”。其代码并不难，但里面下标递增的语句值得斟酌一下。 k=(k+1)%maxn; 这句话用到了取模运算%，是非常浪费时间的。若能避免使用%，则可以大大提高代码运行速度。我做了一个测试，把下面五种语句写法分别运行5×10^8次，在我的机器上用...
线性表，栈和队列（数据结构c++）
weixin_73748464的博客
04-11 309
（1）顺序栈（2）链栈（1）循环队列（2）链队列。
C++实现线性表 - 05 队列（数组实现）
Newin2020的博客
04-02 2458
数据结构与算法C++代码实现之线性表队列部分
C++实现数据结构：特殊线性表——栈、队列与串
"这是一份关于数据结构的C++版电子笔记，主要讲解了特殊线性表中的栈、队列和串的概念与实现。笔记详细介绍了栈的逻辑结构、抽象数据类型定义以及顺序存储结构，同时也探讨了两栈共享空间的问题及其解决方案。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值