顺序栈的基本操作
SeqStack.h
#include<iostream>
using namespace std;
#define MAXSIZE 100
typedef int ElemType ;
typedef struct SeqStack {
int *elem;
int top;
}SeqStack;
/*
初始化一个栈
*/
void InitStack(SeqStack &s);
/*
入栈
*/
void Push(SeqStack &s,ElemType e);
/*
出栈
*/
ElemType Pop(SeqStack &s);
/*
输出元素
*/
void PrintStack(SeqStack &s);
SeqStack.cpp
#include"SeqStack.h"
/*
初始化一个栈
*/
void InitStack(SeqStack &s) {
s.elem=new int[MAXSIZE];
s.top = -1;
}
/*
入栈
*/
void Push(SeqStack &s,ElemType e) {
if (s.top==MAXSIZE-1) {
exit(-1);
}
else {
s.elem[++s.top] = e;
}
}
/*
出栈
*/
ElemType Pop(SeqStack &s) {
if (s.top==-1) {
exit(-1);
}
else {
return s.elem[--s.top];
}
}
/*
输出栈的元素
*/
void PrintStack(SeqStack &s) {
while (s.top>-1) {
cout << s.elem[s.top--]<<" ";
}
}
test.cpp
#include"SeqStack.h"
void main() {
SeqStack s;
InitStack(s);
Push(s, 1);
Push(s, 2);
Push(s, 3);
Push(s, 4);
Pop(s);
PrintStack(s);
}
链栈的基本操作
ListStack.h
#include<iostream>
using namespace std;
typedef int DataType;
typedef struct StackNode {
DataType data;
struct StackNode* next;
}StackNode,*LinkStack;
/*
初始化一个链栈
*/
void InitStack(LinkStack& s);
/*
入栈
*/
void PushStack(LinkStack s,DataType a);
/*
出栈
*/
DataType PopStack(LinkStack s);
/*
输出链栈的元素
*/
void PrintStack(LinkStack s);
ListStack.cpp
#include"ListStack.h"
/*
初始化一个链栈
*/
void InitStack(LinkStack& s) {
s = new StackNode;
s->next = NULL;
}
/*
入栈
*/
void PushStack(LinkStack s,DataType d) {
StackNode* ps=new StackNode;
ps->data = d;
ps->next = s->next;
s->next = ps;
}
/*
出栈
*/
DataType PopStack(LinkStack s) {
if (s->next)
{
StackNode* p = s->next;
s->next = s->next->next;
return p->data;
}
else {
return NULL;
}
}
/*
输出链栈的元素
*/
void PrintStack(LinkStack s) {
while (s->next) {
cout << s->next->data << " ";
s->next = s->next->next;
}
}
test.h
#include"ListStack.h"
void main() {
LinkStack s;
InitStack(s);
PushStack(s, 1);
PushStack(s, 2);
PushStack(s, 3);
PushStack(s, 4);
cout<<PopStack(s)<<"\n";
PrintStack(s);
}
队列的基本操作——循环队列
SeQueue.h
#include<iostream>
using namespace std;
#define MAXSIZE 10
typedef int ElemType;
/*
顺序队列的数据结构
elem :定义的队列
front:队列的头指针,下标从0开始
rear :队列的尾指针,下标从0开始
*/
typedef struct SeQueue {
ElemType *elem;
int front, rear;
}SeQueue;
/*
初始化一个队列
*/
void InitQueue(SeQueue& S);
/*
入队
*/
bool InQueue(SeQueue &S,ElemType e);
/*
出队
*/
bool OutQueue(SeQueue &S,ElemType &e);
/*
打印出队列的元素
*/
void printQueue(SeQueue s);
SeQueue.cpp
#include"SeQueue.h"
/*
初始化一个队列
*/
void InitQueue(SeQueue& S) {
S.elem = new ElemType[MAXSIZE];
if (!S.elem)
exit(-1);
S.front = S.rear = 0;
}
/*
入队
*/
bool InQueue(SeQueue &S, ElemType e) {
if ((S.rear+1)%MAXSIZE==S.front) {
cout << "队列已满";
return false;
}
else {
S.elem[S.rear] = e;
S.rear = (S.rear + 1) % MAXSIZE;
return true;
}
}
/*
出队
*/
bool OutQueue(SeQueue &S, ElemType& e) {
if (S.front == S.rear) {
cout << "队列为空";
return false;
}
else {
e = S.elem[S.front];
S.front = (S.front + 1) % MAXSIZE;
return true;
}
}
/*
求队列长度
*/
int LongQueue(SeQueue s) {
if (s.front == s.rear)
return 0;
else {
return (s.rear - s.front + MAXSIZE) % MAXSIZE;
}
}
/*
打印出队列的元素
*/
void printQueue(SeQueue s) {
if (s.front ==s.rear) {
cout << "这是一个空队列";
}
else {
int longth =LongQueue(s);
cout << "队列的长度为:" << longth<<"\n";
int index = s.front;
for (int i = 0; i < longth;i++) {
cout << s.elem[index]<<" ";
index = (index + 1) % MAXSIZE;
}
}
}
test.cpp
#include"SeQueue.h"
void main() {
SeQueue S;
int e;
InitQueue(S);
for(int i=0;i<9;i++){
InQueue(S,i+1);
}
OutQueue(S,e);
printQueue(S);
cout << "\n出来的是" << e;
}
队列的基本操作——链队列
ListQueue.h
#include<iostream>
using namespace std;
typedef int DataType ;
typedef struct QNode {
DataType data;
struct QNode* next;
}QNode,*QueuePtr;
typedef struct {
QueuePtr front;
QueuePtr rear;
}LinkQueue;
/*
初始化一个队列
*/
void InitQueue(LinkQueue &L);
/*
入队
*/
void In_Queue(LinkQueue &L,DataType e);
/*
出队
*/
void Out_Queue(LinkQueue &L);
/*
打印队列
*/
void PrintQueue(LinkQueue L);
ListQueue.cpp
#include"ListQueue.h"
/*
初始化一个队列
*/
void InitQueue(LinkQueue &L) {
L.rear=L.front=new QNode;
if (!L.front) {
exit(-1);
}
L.front->next = NULL;
}
/*
入队
*/
void In_Queue(LinkQueue& L, DataType e) {
QNode *node=new QNode;
if (!node) {
cout << "创建结点失败\n";
exit(-1);
}
else {
node->data = e;
node->next = NULL;
L.rear->next = node;
L.rear = node;
}
}
/*
出队
*/
void Out_Queue(LinkQueue& L) {
if (L.front==L.rear) {
cout << "队列为空,出失败\n";
exit(-1);
}
else {
QNode* p = new QNode;
p = L.front->next;
L.front->next = p->next;
if (p==L.rear) {
L.rear = L.front;
}
delete p;
}
}
/*
打印队列的元素
*/
void PrintQueue(LinkQueue L) {
if (L.front->next==NULL) {
cout << "队列为空";
exit(-1);
}
else {
/* 生成一个指针P, 指向第一个元素结点, 接着依次向后遍历,
当P == L.rear, P指向了最后一个元素,
则P.next为空,这个就是循环结束的依据*/
QNode* p = new QNode;
p=L.front->next;
while(p){
cout << p->data<<"\n";
p=p->next;
}
}
}
test.cpp
#include"ListQueue.h"
void main() {
LinkQueue L;
InitQueue(L);
for (int i = 0; i < 5;i++) {
In_Queue(L,i+1);
}
for (int i = 0; i < 2; i++) {
Out_Queue(L);
}
PrintQueue(L);
}