目录
目录
自行封装一个栈的类，包含私有成员属性：栈的数组、记录栈顶的变量
成员函数完成：构造函数、析构函数、拷贝构造函数、入栈、出栈、清空栈、判空、判满、获取栈顶元素、求栈的大小
头文件：stack.h
源文件: stack.cpp
测试文件：main.cpp
效果图
自行封装一个循环顺序队列的类，包含私有成员属性：存放队列的数组、队头位置、队尾位置
成员函数完成：构造函数、析构函数、拷贝构造函数、入队、出队、清空队列、判空、判满、求队列大小
头文件：queue.h
源文件: queue.cpp
测试文件：main.cpp
效果图
思维导图
自行封装一个栈的类，包含私有成员属性：栈的数组、记录栈顶的变量
成员函数完成：构造函数、析构函数、拷贝构造函数、入栈、出栈、清空栈、判空、判满、获取栈顶元素、求栈的大小
头文件：stack.h
#ifndef STACK_H
#define STACK_H
#include <iostream>
using namespace std;
class Stack
{
private:
int data[128];
int top;
public:
Stack();
~Stack();
Stack(Stack &s);
//判空
bool stack_empty();
//返回布尔类型，真为空，假为非空
//判满
bool stack_full();
//返回布尔类型，真为满，假为非满
//入栈
int stack_in(int num);
//出栈
int stack_out();
//清空栈
bool stack_clear();
//获取栈顶元素
int stack_get_top();
//求栈的大小
int stack_size();
//为了便于观察现象，加一个展示栈内元素的函数，从栈顶向栈底
void stack_show();
};
#endif // STACK_H
源文件: stack.cpp
#include "stack.h"
Stack::Stack():top(-1){
cout<<"Stack:构造函数"<<endl;
}
Stack::~Stack(){
cout<<"Stack:析构函数"<<endl;
}
Stack::Stack(Stack &s):top(s.top){
for(int i=0; i<=top; i++){
data[i] = s.data[i];
}
cout<<"Stack:拷贝构造函数"<<endl;
}
//判空
bool Stack::stack_empty(){
//top正好记录栈顶元素的下标，所以当top为-1时，栈空
return -1 == top;
}
//判满
bool Stack::stack_full(){
//top正好记录栈顶元素的下标，所以当top为127时，栈满
return 127 == top;
}
//入栈
int Stack::stack_in(int num){
//如果栈满，则拒绝入栈
if(Stack::stack_full()){
cout<<"栈已满"<<endl;
return -1;
}
//将栈顶变量的值+1，就能指向新的栈顶
top++;
//将要入栈的数据放入数组中
data[top] = num;
return 0;
}
//出栈
int Stack::stack_out(){
//判断栈是否为空，为空则无法出栈
if(Stack::stack_empty()){
cout<<"栈已空"<<endl;
return -1;
}
//按照我的定义，top正好记录了栈顶元素的下标,因此top--，会将top自减，并且top--这个表达式
//的值为top，所以可以输出data[top]也就是栈顶元素的值，同时top自减一次，而要出栈，出的
//就是栈顶元素
return data[top--];
}
//清空栈
bool Stack::stack_clear(){
//如果栈本身为空则无需清空
if(Stack::stack_empty()){
cout<<"栈已空"<<endl;
return false;
}
//如果栈非空则需要清空
//将栈顶指针置为-1即可
top = -1;
return true;
}
//获取栈顶元素
int Stack::stack_get_top(){
//首先栈要非空
if(Stack::stack_empty()){
cout<<"栈已空"<<endl;
return -1;
}
//原理与出栈相同，唯一的区别就是无需将栈顶变量移动
return data[top];
}
//求栈的大小
int Stack::stack_size(){
//已知，top变量记录了栈顶元素的下标，所以要求栈中的元素数量，只需将top+1就可得到
return top+1;
}
//为了便于观察现象，加一个展示栈内元素的函数，从栈顶向栈底
void Stack::stack_show(){
//首先栈要非空
if(Stack::stack_empty()){
cout<<"栈为空"<<endl;
return ;
}
for(int i=top; i>-1; i--){
cout << data[i] << " ";
}
cout<<endl;
}
测试文件：main.cpp
#include <iostream>
#include "stack.h"
using namespace std;
int main()
{
Stack s1;
//入栈
s1.stack_in(4);
//展示栈内元素
cout<<"s1:";
s1.stack_show();
s1.stack_in(3);
//展示栈内元素
cout<<"s1:";
s1.stack_show();
s1.stack_in(9);
//展示栈内元素
cout<<"s1:";
s1.stack_show();
s1.stack_in(6);
//展示栈内元素
cout<<"s1:";
s1.stack_show();
s1.stack_in(1);
//展示栈内元素
cout<<"s1:";
s1.stack_show();
s1.stack_in(5);
//展示栈内元素
cout<<"s1:";
s1.stack_show();
s1.stack_in(5);
//展示栈内元素
cout<<"s1:";
s1.stack_show();
s1.stack_in(7);
//展示栈内元素
cout<<"s1:";
s1.stack_show();
//拷贝构造函数的使用
Stack s2(s1);
//展示栈内元素
cout<<"s2:";
s2.stack_show();
//出栈
cout<<s1.stack_out()<<"出栈成功"<<endl;
//展示栈内元素
cout<<"s1:";
s1.stack_show();
cout<<s1.stack_out()<<"出栈成功"<<endl;
//展示栈内元素
cout<<"s1:";
s1.stack_show();
cout<<s1.stack_out()<<"出栈成功"<<endl;
//展示栈内元素
cout<<"s1:";
s1.stack_show();
//获取栈的大小
cout<<"此时栈内元素的数量为:"<<s1.stack_size()<<endl;
//栈顶元素为
cout<<"栈顶元素为:"<<s1.stack_get_top()<<endl;
//清空栈
s1.stack_clear();
cout<<"栈清空成功"<<endl;
//展示栈内元素
cout<<"s1:";
s1.stack_show();
return 0;
}
效果图
自行封装一个循环顺序队列的类，包含私有成员属性：存放队列的数组、队头位置、队尾位置
成员函数完成：构造函数、析构函数、拷贝构造函数、入队、出队、清空队列、判空、判满、求队列大小
头文件：queue.h
#ifndef QUEUE_H
#define QUEUE_H
#include <iostream>
using namespace std;
class Queue
{
private:
int data[12];
int head;
int tail;
public:
//构造函数
Queue();
//析构函数
~Queue();
//拷贝构造函数
Queue(Queue &q);
//判空
bool queue_empty();
//判满
bool queue_full();
//入队
int queue_in(int num);
//出队
int queue_out();
//清空队列
bool queue_clear();
//求队列大小
int queue_size();
//为了便于观察现象，加一个展示队列元素的函数，从队头到队尾
void queue_show();
};
#endif // QUEUE_H
源文件: queue.cpp
#include "queue.h"
//构造函数
Queue::Queue():head(0),tail(0){
cout<<"Queue:构造函数"<<endl;
}
//析构函数
Queue::~Queue(){
cout<<"Queue:析构函数"<<endl;
}
//拷贝构造函数
Queue::Queue(Queue &q):head(q.head),tail(q.tail){
int h = head;
while(h!=tail){
data[h] = q.data[h];
h = (h+1)%12;
}
cout<<"Queue:拷贝构造函数"<<endl;
}
//判空
bool Queue::queue_empty(){
//当队列的头变量与尾变量的值相同时，队列为空
return head == tail;
}
//判满
bool Queue::queue_full(){
//队尾变量记录的下标中是不保存变量的，以便操作与计数
//因此，当队尾变量的值比对头变量的值小1或者-11的时候，队满
return (tail+1)%12 == head;
}
//入队
int Queue::queue_in(int num){
//要能入队，首先队列不能为满
if(Queue::queue_full()){
cout<<"队列已满，无法入队"<<endl;
return -1;
}
//此时可以入队
data[tail] = num;
//队尾变量自增一次
tail = (tail + 1)%12;
return 0;
}
//出队
int Queue::queue_out(){
//要能出队，首先队列不能为空
if(Queue::queue_empty()){
cout<<"队列已空，无法入队"<<endl;
return -1;
}
//此时可以出队
int tmp = data[head];
//对头变量自增一次
head = (head + 1)%12;
return tmp;
}
//清空队列
bool Queue::queue_clear(){
//若队列为空则无需清空
if(Queue::queue_empty()){
cout<<"队列已空，无需清空"<<endl;
return false;
}
//操作队头队尾变量，使满足队列为空的条件
head = tail;
return true;
}
//求队列大小
int Queue::queue_size(){
//根据队首队尾的位置即可求出队列大小
return (tail + 12 - head)%12;
}
//为了便于观察现象，加一个展示队列元素的函数，从队头到队尾
void Queue::queue_show(){
//若队列为空则提示队列为空
if(Queue::queue_empty()){
cout<<"队列为空"<<endl;
return;
}
int h = head;
while(h!=tail){
cout<<data[h]<<" ";
h = (h+1)%12;
}
cout<<endl;
return;
}
测试文件：main.cpp
#include <iostream>
#include "queue.h"
using namespace std;
int main()
{
Queue q1;
//入队
q1.queue_in(4);
//展示
cout<<"q1: ";
q1.queue_show();
//入队
q1.queue_in(3);
//展示
cout<<"q1: ";
q1.queue_show();
//入队
q1.queue_in(9);
//展示
cout<<"q1: ";
q1.queue_show();
//入队
q1.queue_in(6);
//展示
cout<<"q1: ";
q1.queue_show();
//入队
q1.queue_in(1);
//展示
cout<<"q1: ";
q1.queue_show();
//入队
q1.queue_in(5);
//展示
cout<<"q1: ";
q1.queue_show();
//入队
q1.queue_in(5);
//展示
cout<<"q1: ";
q1.queue_show();
//入队
q1.queue_in(7);
//展示
cout<<"q1: ";
q1.queue_show();
//拷贝构造函数
Queue q2(q1);
//展示
cout<<"q2: ";
q2.queue_show();
//出队
cout<<q1.queue_out()<<"出队成功"<<endl;
//出队
cout<<q1.queue_out()<<"出队成功"<<endl;
//出队
cout<<q1.queue_out()<<"出队成功"<<endl;
//展示
cout<<"q1: ";
q1.queue_show();
//求队列大小
cout<<"q1队列大小为"<<q1.queue_size()<<endl;
//清空队列
q1.queue_clear();
cout<<"队列清空成功"<<endl;
//展示
cout<<"q1: ";
q1.queue_show();
//求队列大小
cout<<"q1队列大小为"<<q1.queue_size()<<endl;
return 0;
}
效果图
思维导图
