c++ 算法 开发语言 用模板完成顺序栈和顺序队列

顺序栈 

#include

using namespace std;

#define MAX 50

template

class Stack

{

private:

T *data;

int top;

public:

Stack():data(new T[MAX]),top(-1)

{

cout<<"Stack::无参构造函数"<

}

~Stack()

{

delete []data;

cout<<"Stack::构析函数"<

}

Stack(const Stack &other)

{

if(data!=NULL)

{

delete[]data;

}

this->data=new T[MAX];

memcpy(this->data,other.data,sizeof(T)*MAX);

this->top=other.top;

cout<<"Stack::拷贝构造函数"<

}

void stack_push(T &&val);

void stack_pop();

void stack_clear();

bool stack_empty();

bool stack_full();

T stack_gettop();

int stack_len();

void stack_show();

};

template

void Stack::stack_push(T &&val)

{

this->top++;

this->data[top]=val;

}

template

void Stack::stack_pop()

{

if(NULL==this->data || stack_empty())

{

cout<<"所给顺序栈不合法"<

}

cout<data[top]<<"出栈成功"<

this->top--;

}

template

void Stack::stack_clear()

{

this->top=-1;

}

template

bool Stack::stack_empty()

{

return -1==this->top;

}

template

bool Stack::stack_full()

{

return MAX-1==this->top;

}

template

T Stack::stack_gettop()

{

return this->data[top];

}

template

int Stack::stack_len()

{

return this->top+1;

}

template

void Stack::stack_show()

{

for(int i=top;i>=0;i--)

{

cout<data[i]<<" ";

}

cout<

}

顺序队列

#include

#define MAX 50

using namespace std;

template

class Queue

{

private:

T *data;

T head;

T tail;

public:

Queue():data(new T[MAX]),head((T)0),tail((T)0)

{

cout<<"queue::无参构造函数"<

}

~Queue()

{

delete []data;

cout<<"queue::析构函数"<

}

Queue(const Queue &other):

data(new T(*other.data)),

head(other.head),

tail(other.tail)

{

this->data=new T[MAX];

memcpy(this->data,other.data,sizeof(T)*MAX);

this->head=other.head;

this->tail=other.tail;

cout<<"拷贝构造函数"<

}

void queue_push(T &&val);

void queue_pop();

void queue_clear();

bool queue_empty();

bool queue_full();

int queue_len();

void queue_show();

};

template

void Queue::queue_push(T &&val)

{

data[tail]=val;

tail=(tail+1)%MAX;

return;

}

template

void Queue::queue_pop()

{

cout<

head=(head+1)%MAX;

return;

}

template

void Queue::queue_clear()

{

while(!queue_empty())

{

queue_pop();

}

}

template

bool Queue::queue_empty()

{

return head==tail;

}

template

bool Queue::queue_full()

{

return head==(tail+MAX)%MAX;

}

template

int Queue::queue_len()

{

return (tail+MAX-head)%MAX;

}

template

void Queue::queue_show()

{

for(int i=head;i!=tail;i=(i+1)%MAX)

{

cout<

}

cout<

}

文章来源