栈头文件
cpp
#ifndef MY_STACK_H
#define MY_STACK_H
template <typename T>
class My_Stack
{
private:
T* m_stack;
int m_length;
int m_max;
public:
My_Stack(int len);
My_Stack(const My_Stack& obj);
int length();
int gettop();
bool pop();
bool push(int value);
bool empty();
bool full();
bool show();
bool clear();
~My_Stack();
};
#endif // MY_STACK_H
栈函数实现
cpp
#include "my_Stack.h"
#include <iostream>
using namespace std;
template <typename T>
My_Stack<T>::My_Stack(int len):m_stack(nullptr),m_length(0),m_max(0)
{
m_stack = new T[len];
for(int i = 0; i < len; i++)
{
m_stack[i] = 0;
}
m_max = len;
}
template <typename T>
My_Stack<T>::My_Stack(const My_Stack& obj)
{
m_max = obj.m_max;
m_stack = new T[obj.m_max];
for(int i = 0; i < obj.m_max; i++)
{
m_stack[i] = obj.m_stack[i];
}
}
template <typename T>
int My_Stack<T>::length()
{
return m_length;
}
template <typename T>
int My_Stack<T>::gettop()
{
if(empty())
{
return -1;
}
int &top = m_stack[m_length-1];
return top;
}
template <typename T>
bool My_Stack<T>::pop()
{
bool ret = true;
if(empty())
{
ret = false;
cout << "栈为空" << endl;
return ret;
}
m_length--;
cout << "出栈成功" << endl;
return ret;
}
template <typename T>
bool My_Stack<T>::push(int value)
{
bool ret = true;
if(full())
{
ret = false;
cout << "栈已满" << endl;
return ret;
}
m_stack[m_length] = value;
m_length++;
cout << "入栈成功" << endl;
return ret;
}
template <typename T>
bool My_Stack<T>::empty()
{
return m_length == 0;
}
template <typename T>
bool My_Stack<T>::full()
{
return m_length == m_max;
}
template <typename T>
bool My_Stack<T>::show()
{
bool ret = true;
if(empty())
{
ret = false;
cout << "栈为空" << endl;
return ret;
}
for(int i = 0; i < m_length; i++)
{
cout << m_stack[i] << " ";
}
cout << endl;
return ret;
}
template <typename T>
bool My_Stack<T>::clear()
{
bool ret = true;
if(empty())
{
ret = false;
cout << "栈为空" << endl;
return ret;
}
m_length = 0;
cout << "栈已清空" << endl;
return ret;
}
template <typename T>
My_Stack<T>::~My_Stack()
{
delete[] m_stack;
}
循环队列头文件
cpp
#ifndef MY_QUEUE_H
#define MY_QUEUE_H
template <typename T>
class My_Queue
{
private:
T* m_queue;
int front;
int tail;
int m_length;
public:
My_Queue(int len);
My_Queue(const My_Queue& obj);
int length();
bool pop();
bool push(int value);
bool empty();
bool full();
bool show();
~My_Queue();
};
#endif // MY_QUEUE_H
循环队列函数实现
cpp
#include "my_Queue.h"
#include <iostream>
using namespace std;
template <typename T>
My_Queue<T>::My_Queue(int len):m_queue(nullptr),front(0),tail(0),m_length(0)
{
m_queue = new T[len+1];
for(int i = 0; i < len+1; i++)
{
m_queue[i] = 0;
}
m_length = len+1;
}
template <typename T>
My_Queue<T>::My_Queue(const My_Queue& obj)
{
m_length = obj.m_length;
m_queue = new T[obj.m_length];
for(int i = 0; i < obj.m_length; i++)
{
m_queue[i] = obj.m_queue[i];
}
}
template <typename T>
int My_Queue<T>::length()
{
return (tail + m_length - front) % m_length;
}
template <typename T>
bool My_Queue<T>::pop()
{
bool ret = true;
if(empty())
{
cout << "队列为空" << endl;
ret = false;
return ret;
}
front = (front + 1) % m_length;
cout << "出队成功" << endl;
return ret;
}
template <typename T>
bool My_Queue<T>::push(int value)
{
bool ret = true;
if(full())
{
cout << "队列已满" << endl;
ret = false;
return ret;
}
m_queue[tail] = value;
tail = (tail + 1) % m_length;
cout << "入队成功" << endl;
return ret;
}
template <typename T>
bool My_Queue<T>::empty()
{
return front == tail;
}
template <typename T>
bool My_Queue<T>::full()
{
return (tail + 1) % m_length == front;
}
template <typename T>
bool My_Queue<T>::show()
{
bool ret = true;
if( empty() )
{
ret = false;
cout << "队列为空" << endl;
return ret;
}
for(int i = front; i != tail; i = (i+1)%m_length)
{
cout << m_queue[i] << " ";
}
cout << endl;
return ret;
}
template <typename T>
My_Queue<T>::~My_Queue()
{
delete[] m_queue;
}