数据结构——特殊的线性表（栈和队列）

最新推荐文章于 2021-11-28 16:13:16 发布
最新推荐文章于 2021-11-28 16:13:16 发布
阅读量322 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cure_myself/article/details/115280785
版权

数据结构——特殊线性表的实现（模板类)

一. 栈

1.栈的特点

元素具有后进先出的特性，在链栈中没有头结点

2.顺序栈

1.构造函数
template<typename T>
SeqStack<T>::SeqStack()
{
	top=-1;//栈顶坐标设为-1
}
2.入栈操作
template<typename T>
void SeqStack<T>::Push(T x)
{
	if(top==S-1) throw "上溢";//S为栈的最大长度
	data[++top]=x;
}
3.出栈操作
template<typename T>
T SeqStack<T>::Pop(T x)
{
	if(top==-1) throw "下溢";
	return data[top--];
}
4.取栈顶元素
template<typename T>
T SeqStack<T>::GetTop()
{
	if(top==-1) throw "栈空";
	return data[top];
}
5.判空操作
template<typename T>
int SeqStack<T>::Empty()
{
	if(top==-1) return 1;
	return 0;
}

3.链栈

1.构造函数
template<typename T>
LinkStack<T>::LinkStack()
{
	top=NULL;
}
2.入栈操作
template<typename T>
void LinkStack<T>::Push(T x)
{
	Node<T> *s=NULL;
	s=new Node<T>;
	s->data=x;
	s-next=top;
	top=s;
}
3.出栈操作
template<typename T>
T LinkStack<T>::Pop()
{
	Node<T> *p=NULL;
	T x;
	if(top==NULL) throw "下溢";
	x=top->data;
	p=top;
	top=top->next;
	delete p;
	return x;
}
4.取栈顶元素
template<typename T>
T LinkStack<T>::GetTop()
{
	if(top==NULL) throw "栈空";
	return top->data;
}
5.判空操作
template<typename T>
int LinkStack<T>::Empty()
{
	if(top->data==NULL) return 1;
	return 0;
}

二.队列

1.队列的特点

元素具有先进先出的特性，在队列中有头结点

2.顺序队列

1.构造函数
template<typename T>
CirQueue<T>::CirQueue()
{
	rear=S-1;
	front=S-1;
}
2.入队操作
template<typename T>
void CirQueue<T>::EnQueue(T x)
{
	if((rear+1)%S==front) throw "上溢";
	rear=(rear+1)%S;
	data[rear]=x;
}
3.出队操作
template<typename T>
T CirQueue<T>::DeQueue()
{
	if(rear==front) throw "下溢";
	front=(front+1)%S;
	return data[front];
}
4.取队头元素
template<typename T>
T CirQueue<T>::GetHead()
{
	if(rear==front) throw "下溢";
	return data[(front+1)%S];
}
5.判空操作
template<typename T>
int CirQueue<T>::Empty()
{
	if(rear==front) return 1;
	return 0; 
}

3.链队列

1.构造函数
template<typename T>
LinkQueue<T>::LinkQueue()
{
	Node<T> *s=NULL;
	s=new Node<T>;
	s->next=NULL;
	front=rear=s;
}
2.入队操作
template<typename T>
void LinkQueue<T>::EnQueue(T x)
{
	Node<T> *s=NULL;
	s=new Node<T>;
	s->data=x;
	s->next=NULL;
	rear->next=s;
	rear=s;
}
3.出队操作
template<typename T>
T LinkQueue<T>::DeQueue()
{
	T x;
	Node<T> *p=NULL;
	if(rear==front) throw"下溢";
	p=front->next;
	x=p->next;
	if(p->next==NULL) rear=front;
	delete p;
	return x;
}
4.取队头元素
template<typename T>
T LinkQueue<T>::GetHead()
{
	if(front->next==NULL) throw"队列为空";
	return front->next->data;
}
5.判空操作
template<typename T>
int LinkQueue<T>::Empty()
{
	if(front==rear) return 1;
	retuen 0;
}

三.扩展

两栈共享空间

1.入栈操作
template<typename T>
void BothStack<T>::Push(int i,T x)
{
	if(top1==top2-1) throw "上溢";
	if(i==1) data[++top1]=x;
	else data[++top2]=x;
}
2.出栈操作
template<typename T>
T BothStack<T>::Pop(int i)
{
	if(i==1){
		if(top1==-1) throw"下溢";
		return data[top1--];
	}
	else{
		if(top2==S) throw"下溢";
		return data[top2++];
	}
}

循环队列

#include<iostream>
using namespace std;
const int S=6;
template <typename T>
class CirQueue{
public:
    CirQueue();
    ~CirQueue();
    void EnQueue(T x);
    T DeQueue();
    T GetHead();
    int Empty();
private:
    T data[S];
    int front,rear;
};
template <typename T>
CirQueue<T>::CirQueue(){
    rear=front=S-1;
}
template <typename T>
CirQueue<T>::~CirQueue(){}
template <typename T>
void CirQueue<T>::EnQueue(T x){
    if((rear+1)%S==front) throw "overflow";
    rear=(rear+1)%S;
    data[rear]=x;
}
template <typename T>
T CirQueue<T>::DeQueue(){
    if(rear==front) throw "overflow";
    front=(front+1)%S;
    return data[front];
}
template <typename T>
T CirQueue<T>::GetHead(){
    if(rear==front) throw "overflow";
    return data[(front+1)%S];
}
template <typename T>
int CirQueue<T>::Empty(){
    if(rear==front) return 1;
    else return 0;
}
int main(){
    CirQueue<int> a;
    cout<<a.Empty()<<endl;
    a.EnQueue(1);
    cout<<a.GetHead()<<endl;
    a.EnQueue(2);
    cout<<a.DeQueue()<<endl;
    cout<<a.GetHead()<<endl;
    a.EnQueue(3);
    cout<<a.DeQueue()<<endl;
    cout<<a.GetHead()<<endl;
    a.EnQueue(4);
    cout<<a.DeQueue()<<endl;
    cout<<a.GetHead()<<endl;
    a.EnQueue(5);
    cout<<a.DeQueue()<<endl;
    cout<<a.Empty()<<endl;


}

链栈

#include<iostream>
using namespace std;
template <typename T>
class Node{
public:
    T data;
    Node<T> *next;
};
template <typename T>
class LinkStack{
public:
    LinkStack();
    ~LinkStack();
    void Push(T x);
    T Pop();
    T GetTop();
    int Empty();
private:
    Node<T> *top;
};
template <typename T>
LinkStack<T>::LinkStack(){
    top=nullptr;
}
template <typename T>
LinkStack<T>::~LinkStack(){
    Node<T> *p=nullptr;
    while(top){
        p=new Node<T>;
        p=top;
        top=top->next;
        delete p;
    }
}
template <typename T>
void LinkStack<T>::Push(T x){
    Node<T> *s=nullptr;
    s=new Node<T>;
    s->data=x;
    s->next=top;
    top=s;
}
template <typename T>
T LinkStack<T>::Pop(){
    Node<T> *p=top;
    if(top) {
        top=top->next;
        delete p;
        return top->data;
    }
    else throw "overflow";
}
template <typename T>
T LinkStack<T>::GetTop(){
    if(top) return top->data;
    else throw "overfolw";
}
template <typename T>
int LinkStack<T>::Empty(){
    if(top) return 0;
    else return 1;
}
int main(){
    LinkStack<int> a;
    cout<<a.Empty()<<endl;
    a.Push(1);
    a.Push(2);
    a.Push(3);
    cout<<a.Empty()<<endl;
    cout<<a.GetTop()<<endl;
    cout<<a.Pop()<<endl;
    cout<<a.GetTop()<<endl;

}

顺序栈

#include<iostream>
using namespace std;
const int S=100;
template <typename T>
class SeqStack{
public:
    SeqStack();
    ~SeqStack();
    void Push(T x);
    T Pop();
    T GetTop();
    int Empty();
private:
    T data[S];
    int top;
};
template <typename T>
SeqStack<T>::SeqStack(){
    top=-1;
}
template <typename T>
SeqStack<T>::~SeqStack(){}
template <typename T>
void SeqStack<T>::Push(T x){
    if(top==S-1) throw "overflow";
    else data[++top]=x;
}
template <typename T>
T SeqStack<T>::Pop(){
    if(top==-1) throw "overflow";
    else return data[top--];
}
template <typename T>
T SeqStack<T>::GetTop(){
    if(top==-1) throw "overflow";
    else return data[top];
}
template <typename T>
int SeqStack<T>::Empty(){
    if(top==-1) return 1;
    else return 0;
}
int main(){
    SeqStack<int> a;
    cout<<a.Empty()<<endl;
    a.Push(1);
    cout<<a.GetTop()<<endl;
    a.Push(2);
    cout<<a.GetTop()<<endl;
    a.Push(3);
    cout<<a.GetTop()<<endl;
    a.Push(4);
    cout<<a.GetTop()<<endl;
    a.Push(5);
    cout<<a.GetTop()<<endl;
    while(!a.Empty()){
        cout<<a.Pop()<<endl;
        cout<<a.GetTop()<<endl;
    }
}

链队列

#include<iostream>
using namespace std;
const int S=6;
template <typename T>
class Node{
public:
    T data;
    Node<T> *next;
};
template <typename T>
class LinkQueue{
public:
    LinkQueue();
    ~LinkQueue();
    void EnQueue(T x);
    T DeQueue();
    T GetHead();
    int Empty();
private:
    Node<T> *front,*rear;
};
template <typename T>
LinkQueue<T>::LinkQueue(){
    Node<T> *s=nullptr;
    s=new Node<T>;
    s->next=nullptr;
    front=rear=s;
}
template <typename T>
LinkQueue<T>::~LinkQueue(){
    Node<T> *p=nullptr;
    while(front!=rear){
        p=new Node<T>;
        p=front->next;
        front->next=p->next;
        delete p;
    }
}
template <typename T>
void LinkQueue<T>::EnQueue(T x){
    Node<T> *s=nullptr;
    s=new Node<T>;
    s->data=x;
    s->next=nullptr;
    rear->next=s;
    rear=s;
}
template <typename T>
T LinkQueue<T>::DeQueue(){
    if(rear==front) throw "overflow";
    Node<T> *p=front->next;
    T x=p->data;
    front->next=p->next;
    if(p->next==nullptr) rear=front;
    delete p;
    return x;

}
template <typename T>
T LinkQueue<T>::GetHead(){
    if(front==rear) throw "overflow";
    return front->next->data;
}
template <typename T>
int LinkQueue<T>::Empty(){
    if(front==rear) return 1;
    else return 0;
}
int main(){
    LinkQueue<int> a;
    cout<<a.Empty()<<endl;
    a.EnQueue(1);
    cout<<a.Empty()<<endl;
    a.EnQueue(2);
    cout<<a.GetHead()<<endl;
    cout<<a.DeQueue()<<endl;
    cout<<a.GetHead()<<endl;

}
cure_myheart
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
重学数据结构与算法(05)--栈：后进先出的线性表，如何实现增删查？
姜皓的博客
06-11 490
栈：后进先出的线性表如何实现增删查1）栈是什么？2）栈的基本操作 线性表是使用非常广泛的一类数据结构，它对数据的顺序非常敏感，而且它对数据的增删操作非常灵活。在有序排列的数据中，可以灵活的执行增删操作，就好像是为排好队的数据增加了插队的入口。这既是灵活性也是缺陷，原因在于它的灵活性在某种程度上破坏了数据的原始顺序。在某些需要严格遵守数据处理顺序的场景下，我们就需要对线性表予以限制了。经过限制后的线性表，它们通常会被赋予一些新的名字,这一课时来学习其中一个限制后的线性表–栈 1）栈是什么？ 你需要牢记一点，栈
数据结构 特殊线性表---栈、队列、串
qq_51308613的博客
03-25 1520
特殊线性表----栈、串、队列 简单知识 前中后缀表达式转换 模式匹配：KMP算法、BT算法
SeqStack(Template<class T>)实现
肥宅Sean
10-12 1706
顺序表实现模板栈（第二次） 这是发过的一个版本的栈的链接 这次用模板再做了一遍 配有测试过的main函数，可以直接学习使用。#include <iostream> using namespace std;template<class T> class SeqStack{ public: SeqStack(int sz = 50); ~SeqStack(){ delete[]el
SeqStack——顺序堆栈
大数据实验室
03-26 1744
/* ** File name: SeqStack.h ** Author: ZhouFeng ** Date: 2012/03/26 */ #ifndef SEQ_STACK_H #define SEQ_STACK_H #define MAX_SIZE 100 #define ERROR 0 #define SUCCESS 1 #define TRUE 1 #defin
数据结构(java版)Stack(栈)SeqStack(顺序栈)LinkedStack(链式栈)
qq_41997592的博客
11-19 920
Stack(栈) public interface Stack<T> { boolean isEmpty(); void push(T var1); T peek(); T pop(); } SeqStack(顺序栈) public final class SeqStack<T> implements Stack<T> { private final SeqList<T> list; public
数据结构基础系列(3)：栈和队列
06-08
系列课程包含11个部分，本课为第3部分栈和队列，介绍在系统软件和应用软件开发中大有用途的两种特殊线性表——栈和队列的构组成、存储结构的选择，以及基本运算的实现，通过相关的应用案例介绍了这些数据结构的应用...
数据结构笔记：双端队列
01-21
双端队列（deque，double-ended queue），是一种具有队列和栈的性质的数据结构。 双端队列中每一端，都可以进行存入和取出，去其中一段，都像一个栈一样。 存取也只限定在两端，不能在中间 双端队列的实现 通过...
第3章 栈和队列.ppt
06-05
本章的基本内容是： 两种特殊的线性表——栈和队列 从数据结构角度看，栈和队列是操作受限的线性表，他们的逻辑结构相同。 从抽象数据类型角度看，栈和队列是两种重要的抽象数据类型。
数据结构与算法 Python语言描述 ——裘宗燕版
07-05
数据结构与算法 Python语言描述-裘宗燕 高清带目录 详细讲述线性表 、字符串、栈和队列、二叉树和树、图、字典和集合、排序等
声明一个顺序栈类
读书就是赚钱
12-05 1279
package DataStructureTest; public class SeqStack implements SStack { private int top;//声明一个栈顶元素下标 private Object element[]; public SeqStack(int size) { this.element=new Object[Math.abs(size)
顺序栈的实现
weixin_34179968的博客
06-27 188
代码 //顺序栈类SeqStack<T>的实现说明如下所示。publicclassSeqStack<T>:IStack<T>{privateintmaxsize;//顺序栈的容量privateT[]data;//数组，用于存储顺序栈中的数据元素privateint...
特殊线性表--栈
power_guoxinzhao的专栏
01-12 412
什么是栈（stack）            栈是一种特殊的线性表，限定值能在表的一端进行插入和删除操作，俗称“后进先出”（FILO）。            操作数据的这段是表头，称为栈顶；相应的，表尾称为栈底。不含任何元素的栈称为空栈。 栈的基本操作： push:压栈或入栈操作。 pop:弹栈或出栈操作 peek:查看栈顶数据，而不弹出数据，也就是不做出栈操作。 代码实现： p...
数据结构——特殊的线性表（队列）
m0_61705102的博客
11-28 802
定义：队列是一种只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
特殊的线性表-队列
路漫漫其修远兮
12-26 951
链接： （1）线性表(用数组描述) （2）线性表(用链表描述) （3）特殊线性表(栈)   1 队列的定义 队列(queue)是一个线性表，其插入和删除操作分别在表的不同端进行。 队列是一种先进先出不(First In First Out)的线性表，简称FIFIO。插入元素的那一端称为队尾(back或rear)，删除元素的那一端称为队首(front)。 假设队列是 q=(a1,a...
特殊线性表--队列
power_guoxinzhao的专栏
01-12 265
什么是队列（Queue）         队列是一种特殊的线性表，限定只能在表的一端进行插入（队尾），而在另外一端进行删除操作（队头），特点是“先进先出”（FIFO）。 队列的基本操作： 1.insert:在队尾插入数据。 2.remove:从对头移走数据 3.peek:查看对头的数据。 循环队列 ：为了避免队列不满，却不能插入新数据项的问题，可以让队头队尾的指针绕回到数组开始的位置，...
特殊线性表——队列
qq_43628500的博客
11-11 205
定义：只允许在一端进行插入操作，而另一端进行删除操作的线性表。 空队列：不含任何数据元素的队列。 允许插入（也称入队、进队）的一端称为队尾，允许删除（也称出队）的一端称为队头。 队列的操作特性：先进先出。 队列的顺序存储结构及实现 顺序队列：队列的顺序存储结构 1.队头指针指向队列中的第一个元素之前的元素，队尾指针指向队列中的最后一个元素。 2、队头指针指向队列中的第一个元素，队尾指针指向队列中的...
[转]特殊线性表(queue)
weixin_30892763的博客
04-18 101
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。 在队列这种数据结构中，最先插入的元素将是最先被删除的元素；反之最后插入的元素将是最后被删除的元素，因此队列又称为“先进先出”（FIFO...
特殊的线性表-栈
路漫漫其修远兮
11-09 1219
链接1：线性表（数组实现） 链接2：线性表（链表实现） 1 栈的定义 栈（stack，zhan）：把线性表的插入和删除操作限制在同一端进行，就得到栈数据结构。 把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom），不含任何数据元素的栈称为空栈。栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构。 栈是一个线性表，栈元素具有线性关系，即...
串（字符串）---特殊的线性表
qq_44723296的博客
10-16 5908
串（字符串） 串是一种特殊的线性表，其数据元素仅仅由一个字符组成， 计算机非数值时处理的对象经常是字符串数据 1.串的概念 串是由零个或多个任意字符组成的字符序列 2.串的术语 一个串的任意个连续的字符组成的子序列称为该串的子串，包含该子串的串称为主串 串相等： 两个串的长度相等且对应的字符都相等 3.串的存储方式 对串的存储方式取决于我们对串的运算。如果只是输入或输出常量出现， 则需要...
线性表、栈和队列都是什么结构
最新发布
05-15
线性表、栈和队列都是数据结构中常用的基本数据类型。 线性表是指数据元素之间存在一对一的线性关系，即除了第一个和最后一个元素，其它每个元素都恰好有一个前驱和一个后继。线性表可以用顺序存储结构和链式存储结构实现。 栈是一种特殊的线性表，只能在表的一端进行插入或删除操作。这一端被称为栈顶，另一端被称为栈底。栈的特点是后进先出（Last In First Out，LIFO）。 队列也是一种特殊的线性表，只能在队尾插入元素，在队头删除元素。队列的特点是先进先出（First In First Out，FIFO）。 总的来说，线性表、栈和队列都是基本的数据结构，它们在算法和程序设计中都有广泛的应用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值