stack.h

#ifndef STACK_H
#define STACK_H
#include <iostream>
//#define max 128
using namespace std;
class Stack
{
private:int* stack;//数组指针int top;//栈顶元素int max;//栈容量
public://构造函数Stack();//析构函数~Stack();//定义拷贝构造函数Stack(const Stack &other);//入栈void push(int item);//出栈int pop();//清空栈void clear();//遍历栈void stack_show();//判空bool empty();//判满bool full();//获取栈顶元素int stack_top();//求栈的大小int stack_size();
};
#endif // STACK_H

stack.c

#include"stack.h"//构造函数
Stack::Stack():stack(nullptr),top(-1),max(128)
{stack = new int[max];for(int i=0;i<max;i++){stack[i]=0;}
}
//拷贝函数
Stack::Stack(const Stack& other)
{max = other.max;stack = new int[other.max];for(int i = 0; i < other.max; i++){stack[i] = other.stack[i];}
}//入栈
void Stack::push(int item)
{if (full()){cout << "Stack is full." << endl;return;}stack[++top] = item;cout << "push success" << endl;
}//出栈
int Stack::pop()
{if (empty()){cout << "Stack is empty." << endl;return -1;}int item = stack[top--];return item;
}
//清空栈
void Stack::clear()
{top = -1;
}
//遍历栈
void Stack::stack_show()
{for(int i=0;i<top+1;i++){cout<<stack[i]<<endl;}
}//判空
bool Stack::empty()
{return top == -1;
}//判满
bool Stack::full()
{return top == max-1;
}
//获取栈顶元素
int Stack::stack_top()
{if (empty()){cout << "Stack is empty." << endl;return -1;}return stack[top];
}
//求栈的大小
int Stack::stack_size()
{return top + 1;
}

 queue.h

#ifndef QUEUE_H
#define QUEUE_H
#include <iostream>
using namespace std;class Queue
{
public://构造函数Queue(int size);//析构函数~Queue();//拷贝函数Queue(const Queue& other);//入队bool enqueue(int a);//出队bool dequeue();//清空void clear();//判空bool isEmpty();//判满bool isFull();//获取队列大小int getSize();private:int* queue;//队列数组int size;//队列大小int front;//队头int rear;//队尾
};#endif // QUEUE_H

 queue.c

#include"queue.h"Queue::Queue(int size)
{this->size = size;queue = new int[size];         // 根据队列容量动态分配数组内存front = -1;                        // 初始化队头位置为-1rear = -1;                         // 初始化队尾位置为-1
}Queue::~Queue()
{delete queue;                    // 释放数组内存空间
}Queue::Queue(const Queue& other)
{size = other.size;          // 复制队列容量queue = new int[size];          // 根据队列容量动态分配数组内存front = other.front;                // 复制队头位置rear = other.rear;                  // 复制队尾位置for (int i = front; i != rear; i = (i + 1) % size){queue[i] = other.queue[i];      // 复制数组元素}queue[rear] = other.queue[rear];    // 复制数组元素
}bool Queue::enqueue(int a)
{if (isFull())                       // 判断队列是否已满{cout << "Queue is full." << endl;    // 输出错误信息return false;                                  // 入队失败，返回false}if (isEmpty())                      // 如果队列为空{front = 0;                      // 更新队头位置为0}rear = (rear + 1) % size;        // 更新队尾位置，考虑循环queue[rear] = a;                  // 将元素a入队return true;                         // 入队成功，返回true
}bool Queue::dequeue()
{if (isEmpty())                      // 判断队列是否为空{cout << "Queue is empty." << endl;    // 输出错误信息return false;                                  // 出队失败，返回false}if (front == rear)                  // 如果队列中只有一个元素{front = -1;                     // 更新队头位置为-1rear = -1;                      // 更新队尾位置为-1}else{front = (front + 1) % size;  // 更新队头位置，考虑循环}return true;                        // 出队成功，返回true
}void Queue::clear()
{front = -1;                         // 清空队列，更新队头位置为-1rear = -1;                          // 清空队列，更新队尾位置为-1
}bool Queue::isEmpty()
{return front == -1 && rear == -1;   // 判断队列是否为空，根据队头位置和队尾位置是否都为-1
}bool Queue::isFull()
{return (rear + 1) % size == front;    // 判断队列是否已满，根据队尾位置加1取模后是否等于队头位置
}int Queue::getSize()
{if (isEmpty())                      // 如果队列为空{return 0;                       // 返回队列大小为0}if (front <= rear)                  // 如果队头位置小于等于队尾位置{return rear - front + 1;        // 返回队列大小为队尾位置减去队头位置再加1}else{return size - front + rear + 1;   // 返回队列大小为队列容量减去队头位置再加上队尾位置再加1}
}