队列
#include <iostream>
#define N 10
using namespace std;
template <typename T>
class Queue
{
private:
T *data; //数组容器
int head; //队头元素下标
int tail; //队尾元素下标的下一位
public:
//构造函数
template <typename T>
Queue<T>::Queue():data(new T[N]), head(0), tail(0)
{
cout<<"无参构造函数"<<endl;
}
//析构函数
template <typename T>
Queue<T>::~Queue()
{
dalete []data;
cout<<"析构函数"<<endl;
}
//拷贝构造函数
template <typename T>
Queue<T>::Queue(const & Queue):data(new T[N]),head(other.head),tail(other.tail)
{
int i = head;
while(i!=tail)
{
data[i] = s.data[i];
i = (i+1)%N;
}
cout<<"Queue:拷贝构造函数"<<endl;
}
//判空
template <typename T>
bool Queue<T>::empty_queue()
{
if(head == tail)
{
return 1;
}
return 0;
}
//判满
template <typename T>
bool Queue<T>::full_queue()
{
if((tail+1)%N == head)
{
return 1;
}
return 0;
}
//入队
template <typename T>
int Queue<T>::input_queue(T n)
{
if(full_queue())
{
cout<<"队满,入队失败"<<endl;
return -1;
}
data[tail] = n;
tail = (tail+1)%N; //队尾下标自增
return 0;
}
//出队
template <typename T>
int Queue<T>::output_queue()
{
if(empty_queue())
{
cout<<"队空,出队失败"<<endl;
return -1;
}
cout<<data[head]<<endl;;
head = (head+1)%N; //队头自增
return 0;
}
//清空队
template <typename T>
int Queue<T>::delete_queue()
{
if(empty_queue())
{
cout<<"队空,无需清空"<<endl;
return -1;
}
head = tail;
cout<<"清空成功"<<endl;
return 0;
}
//求队列大小
template <typename T>
void Queue<T>::size_queue()
{
cout<<"队列大小为"<<(tail+N-head)%N<<endl;
}
//遍历栈内元素
template <typename T>
int Queue<T>::show_queue()
{
if(empty_queue())
{
cout<<"队空,遍历失败"<<endl;
return -1;
}
for(int i=head; i!=tail; i=(i+1)%N)
{
cout<<data[i];
}
cout<<endl;
return 0;
}
};
int main()
{
Queue<int> q;
q.input_queue(9); //入队
q.input_queue(8);
q.input_queue(7);
q.input_queue(6);
q.input_queue(5);
q.show_queue(); //遍历队列
q.output_queue(); //出队
q.show_queue(); //遍历队列
q.size_queue(); //队列大小
q.delete_queue(); //清空队列
q.show_queue();
return 0;
}
栈
#include <iostream>
#define SIZE 10
using namespace std;
//定义一个模板函数
template<typename T>
class Stack
{
private:
T *data; //栈的数组
int top; //栈顶变量
public:
//构造函数
Stack<T>::Stack<T>()
{
data = new T[SIZE];
this->top = -1;
}
//析构函数
Stack<T>::~Stack<T>()
{
delete []data;
cout<<"析构函数"<<endl;
}
//判空
bool Stack<T>::Stack<T>::empty_stack()
{
if(-1 == top)
{
cout<<"栈为空!"<<endl;
return 1;
}
return 0;
}
//判满
bool Stack<T>::full_stack()
{
if(SIZE == top)
{
cout<<"栈已满!"<<endl;
return 1;
}
return 0;
}
//入栈
int Stack<T>::input_stack(T a)
{
if(full_stack()) //判满操作
{
cout<<"栈满,入栈失败"<<endl;
return -1;
}
top++;
data[top] = a;
return 0;
}
//出栈
int Stack<T>::output_stack()
{
if(empty_stack()) //判空操作
{
cout<<"栈空,出栈失败"<<endl;
return -1;
}
cout<<data[top--];
cout<<"出栈成功"<<endl;
return 0;
}
//求栈顶元素
void Stack<T>::head_stack()
{
cout<<"栈顶元素为"<<data[top]<<endl;
}
//清空栈
void Stack<T>::delete_stack()
{
empty_stack();
top=-1;
cout<<"栈已清空"<<endl;
}
//求栈的大小
void Stack<T>::size_stack()
{
cout<<"栈的大小为"<<top+1<<endl;
}
//拷贝构造函数
Stack<T>::(Stack &s1):top(T s1.top)
{
for(int i=0; i<=top; i++){
data[i] = s1.data[i];
}
cout<<"Stack:拷贝构造函数"<<endl;
}
//遍历栈
void Stack<T>::show_stack()
{
full_stack();
for(int i=top; i>=0; i--)
{
cout<<data[i]<<endl;
}
cout<<"遍历成功"<<endl;
}
};
int main()
{
Stack<int> s;
s.input_stack(8); //入栈
s.input_stack(7);
s.input_stack(6);
s.input_stack(5);
s.input_stack(4);
s.show_stack(); //遍历栈
s.output_stack(); //出栈
s.show_stack();
s.size_stack(); //栈的大小
s.head_stack(); //栈顶元素
s.delete_stack(); //清空栈
s.show_stack();
return 0;
}