数据结构与算法基础（王卓）（13）：小结：关于队列和栈的定义及其基础操作

宇 -Yu

已于 2023-05-04 09:08:55 修改

阅读量142

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构（王卓）文章标签： c++ 链表开发语言

于 2023-03-03 17:29:13 首次发布

本文链接：https://blog.csdn.net/Zz_zzzzzzz__/article/details/128891752

数据结构（王卓）专栏收录该内容

44 篇文章

订阅专栏

本文详细介绍了四种基本数据结构的实现，包括顺序栈的构造、判断空栈、获取栈长、清空栈、销毁栈、压栈和弹栈操作；链栈的创建、判断空栈、压栈和弹栈；循环队列的初始化、获取队头元素、入队和出队；以及链队的初始化、入队、出队和获取队头元素。所有实现均采用C++语言。

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

顺序栈：

//基于线性表的定义所做的更改
#include<iostream>
using namespace std;
#include<stdlib.h>//存放exit
#include<math.h>//OVERFLOW,exit

#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE  -1
//#define OVERFLOW   -2   

#define MAXlength 100  
//可按需修改，PPT中写的是MAXlength

struct Poly
{
	float p;
	int e;

	bool operator==(Poly t)
	{
		return t.p == p && t.e == e;
	}
	bool operator!=(Poly t)
	{
		return t.p != p || t.e != e;
	}
};

struct Sqlist
{
	Poly* elem;
	int length;
};

typedef int Status; 
typedef Poly Elemtype;
typedef Elemtype SElemType;
//注意：这一段必须写在调用SElemType类型及其指针之前

struct SqStack
{
	SElemType* base; //栈底指针  
	SElemType* top;//栈顶指针
	int stacksize; //栈可用最大容量
};

Status InitStack(SqStack& S)//构造一个空栈
{
	S.base = new SElemType[MAXlength];
	//或
	//S.base = (SElemType*)malloc(MAXlength * sizeof(SElemType));
	if (!S.base) exit(OVERFLOW);// 存储分配失败
	S.top = S.base;
	//栈顶指针等于栈底指针
	S.stacksize = MAXlength;
	return true;
}

Status StackEmpty(SqStack S)
{
	// 若栈为空，返回TRUE；否则返回FALSE 
	if (S.top == S.base)
		return TRUE;
	else
		return FALSE;
}

int StackLength(SqStack S)
{
	return S.top - S.base;
}

Status ClearStack(SqStack S)//清空顺序栈
{
	if (S.base)
		S.top = S.base;
	return OK;
}

Status DestroyStack(SqStack& S)//销毁
{
	if (S.base)
	{
		delete S.base;
		S.stacksize = 0;
		S.base = S.top = NULL;
	}
	return OK;
}

Status Push(SqStack& S, SElemType e)
{
	if (S.top-S.base==S.stacksize)
		//不是MAXlength
		return OVERFLOW;
	*S.top = e;
	S.top++;
	//也可以写成：
	//*S.top++ = e;
	return true;
}

Status Pop(SqStack& S, SElemType& e)
//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK;	否则返回ERROR
{
	if (S.top == S.base) // 等价于 if(StackEmpty(S))
		return UNDERFLOW;//ERROR;
	e = *S.top;
	S.top--;
	//e = *--S.top;
	return true;
}

int main()
{

}

链栈

//基于链表的定义所做的更改
#include<iostream>
using namespace std;
#include<stdlib.h>//存放exit

#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE  -1
//#define OVERFLOW   -2   

#define MAXlength 100  //初始大小为100，可按需修改

struct K//Poly
{
    float a;
    int b;
    string c;
    bool operator==(K& t)
    {
        return t.a == a && t.b == b;
        //&& t.c = c;
    }
    bool operator!=(K& t)
    {
        return t.a != a || t.b != b;
        //|| t.c = c;
    }
};
typedef K Elemtype;         //函数调用状态

struct Lnode
    //node:结; 结点;
{
    Elemtype data;
    Lnode* next;
};
typedef Lnode* LinkList;

typedef int Status;
typedef K Elemtype;
typedef Elemtype SElemType;
//注意：这一段必须写在调用SElemType类型及其指针之前

struct StackNode
{
    SElemType data;
    StackNode* next;
};
typedef StackNode* LinkStack;
LinkStack S;

int InitStack(LinkStack& S)
{
    //构造一个空栈，栈顶指针置为空
    S = NULL;
    return OK;
}

Status StackEmpty(LinkStack S)
{
    if (S == NULL)
        return TRUE;
    else return FALSE;
}

SElemType GetTop(LinkStack S)
{
    if (S != NULL)
        return S->data;
}

Status Push(LinkStack& S, SElemType e)
{
    StackNode* p = new StackNode;
    p->data = e;
    p->next = S;

    S = p;

    return true;
}

Status Pop(LinkStack& S, SElemType& e)
{
    if (S == NULL) return ERROR;
    LinkStack p = S;
    e = p->data;
    S = p->next;
    delete p;
    return true;
}

int main()
{

}

循环队列

#include<iostream>
using namespace std;
#include<stdlib.h>//存放exit
#include<math.h>//OVERFLOW,exit

#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE  -1
#define OVERFLOW   -2   

struct Poly
{
    float p;
    int e;

    bool operator==(Poly t)
    {
        return t.p == p && t.e == e;
    }
    bool operator!=(Poly t)
    {
        return t.p != p || t.e != e;
    }
};

struct Sqlist
{
    Poly* elem;
    int length;
};

typedef Poly QElemType;
typedef int Status;         //函数调用状态
#define MAXQSIZE 100  //初始大小为100，可按需修改

struct SqQueue//循环队列定义
{
    QElemType* base;//初始化的动态分配存储空间
    int rear;//头指针
    int front;//尾指针
};

Status InitQueue(SqQueue &Q)//初始化
{
    Q.base = new QElemType[MAXQSIZE];
    //Q.base = (QElemType*)malloc(MAXQSIZE * sizeof(QElemType));
    if (!Q.base) exit(OVERFLOW);//存储分配失败
    Q.rear = Q.front = 0;
    return true;
}

Status Queuelength(SqQueue Q)//求长度
{
    return(Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}

QElemType GetHead(SqQueue Q)//取队头元素
{
    if (Q.front != Q.rear)
        //别忘排除空表的情况
        return(Q.base[Q.front]);
}

Status EnQueue(SqQueue& Q, QElemType e)//入队
{
    if ((Q.rear + 1) % MAXQSIZE == Q.front)
        return OVERFLOW;
    Q.base[Q.rear] = e;
        //这里rear只是下标，不是指针，所以只能这样用
    Q.rear = (Q.rear + 1) % MAXQSIZE;
    return true;
}

Status DeQueue(SqQueue& Q, QElemType e)//出队
{
    if (Q.front == Q.rear)
        return NULL;
    e = Q.base[Q.front];
    Q.front = (Q.front + 1) % MAXQSIZE;
    return true;
}

Status QueneEmpty(SqQueue& Q)
{
    if (Q.front == Q.rear)
        return true;
    else
        return false;
 }

int main()
{

}

链队

//链队的定义及其基础操作
#include<iostream>
using namespace std;
#include<stdlib.h>//存放exit

#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE  -1
#define OVERFLOW   -2   


typedef int Status;         //函数调用状态

struct K
{
    float a;
    int b;
    string c;
    bool operator==(K& t)
    {
        return t.a == a && t.b == b;
        //&& t.c = c;
    }
    bool operator!=(K& t)
    {
        return t.a != a || t.b != b;
        //|| t.c = c;
    }
};
typedef K Elemtype;         //函数调用状态

struct Lnode
    //node:结; 结点;
{
    Elemtype data;
    Lnode* next;
};
typedef Lnode* LinkList;

typedef K QElemType;
typedef int Status;         //函数调用状态
#define MAXQSIZE 100  //初始大小为100，可按需修改

struct QNode
{
    QElemType data;
    QNode* next;
};
typedef QNode *QuenePtr;//Pointer

struct LinkQueue
{
    QuenePtr front; // 队头指针
    QuenePtr rear; // 队尾指针
   // QNode* front; // 队头指针
    //QNode* rear; // 队尾指针
};

Status InitQueue(LinkQueue& Q)//初始化
{
    Q.front = Q.rear = new QNode;
    if (!Q.front)
        return false;
    Q.rear->next = NULL;
    return true;
}

Status DesQueue(LinkQueue& Q)//销毁
{
    while (Q.front)
    {
        QNode* p = Q.front->next;
        delete (Q.front); 
        Q.front = p;
    }
    //也可以直接指定指针rear暂时储存Q.front->next的地址，反正他放在这闲着也没事
    //Q.rear=Q.front->next; free(Q.front); Q.front=Q.rear;
    return OK;
}



Status EnQueue(LinkQueue& Q, QElemType e)//入队
{
    QNode* p = new QNode;
    //QNode* p = (QuenePtr)malloc(sizeof(QNode));
    p->data = e;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;
    return OK;
}

Status DeQueue(LinkQueue& Q, QElemType e)//出队
{
    if (Q.front == Q.rear) return ERROR;
    QNode* p = Q.front->next;
    e = p->data;//保存删除的信息
    Q.front->next = p->next;
    if (Q.rear == p)
        Q.rear = Q.front;
    delete p;
    return true;
}

Status GetHead(LinkQueue Q, QElemType& e)
{
    if (Q.front == Q.rear) return ERROR;
    e = Q.front->next->data;
    return OK;
}

Status QueneEmpty(LinkQueue& Q)
{
    if (Q.front == Q.rear)
        return true;
    else
        return false;
 }

int main()
{

}