c++ 通过顺序表，链表实现队列操作,使用模板类

使用模板类不能在使用typedef，系统无法分配内存

同时模板指针格式应为 mytemplate<elment>*  ,mytemplate<elment>是一种格式，而不是

mytemplate*<elment>, 不存在数据类型mytemplate*，在创建指针时应指出变量类型所以应为

mytemplate<elment>* 

​
#include<iostream>
using namespace std;
#define seq_maxlength 10


/*
*使用顺序表完成队列操作
*队尾下标指向下一个待填充下标
*其中empty full getlength getfront为牺牲一个存储单元的队列
* 带下标为1的则使用特殊方法不牺牲存储单元 
* 牺牲存储单元的判断是否为空看 front==rear 满时(rear+1)%seq_maxlength ==front
*不牺牲使用标志位flag，每次入队置为真，出队置为假，队满标志位一定为真反之为假，同时有front==rear
* 更简单的方法添加元素length记录长度
* 对于牺牲存储单元的长度可用公式 （rear-front+seq_maxlength）%seq_maxlength计算
* 若不牺牲存储单元可用length或对队满单独论论
*使用模板类定义数组未初始化编译器可能warnning所以可以使用动态分配
*/
template <class elment>
class quence1
{
public:
	quence1();
	bool empty();
	bool full();
	bool empty1();
	bool full1();
	int get_length();
	int get_length1();
	bool enqu(elment data);
	bool dequ(elment& data);
	bool get_front(elment& data);
	bool enqu1(elment data);
	bool dequ1(elment& data);
	bool get1_front(elment& data);
private:
	elment que[seq_maxlength];
	int front;
	int rear;
	int length;
	bool flag;
	
};

template <class elment>
bool quence1<elment> ::empty()
{
	return rear==front;
}

template <class elment>
bool quence1<elment> ::full()
{
	return (rear + 1) % seq_maxlength == front;
}


template <class elment>
bool quence1<elment> ::empty1()
{
	return length==0&&(front==rear&&flag==false);
}

template <class elment>
bool quence1<elment> ::full1()
{
	return length == seq_maxlength && (front == rear && flag == true);
}

template <class elment>
quence1<elment>::quence1()
{
	front = rear = 0;
	flag = false;
	length = 0;
}

template <class elment>
int quence1<elment>::get_length1()
{
	return full1() ? seq_maxlength : (rear - front + seq_maxlength) % seq_maxlength;
}

template <class elment>
int quence1<elment>::get_length()
{
	return (rear - front + seq_maxlength) % seq_maxlength;
}

template <class elment>
bool quence1<elment>::enqu(elment data)
{
	if (!full())
	{
		que[rear] = data;
		rear = (rear + 1) % seq_maxlength;
		flag = true;
		length++;
		return true;
	}
	else
	{
		cout << "quence full, enqu failed" << endl;
		return false;
	}
}


template <class elment>
bool quence1<elment>::enqu1(elment data)
{
	if (!full1())
	{
		que[rear] = data;
		rear = (rear + 1) % seq_maxlength;
		flag = true;
		length++;
		return true;
	}
	else
	{
		cout << "quence full, enqu failed" << endl;
		return false;
	}
}


template <class elment>
bool quence1<elment>::dequ(elment& data)
{
	if (!empty())
	{
		data = que[front];
		front = (front +1) % seq_maxlength;
		flag = false;
		length--;
		return true;
	}
	else
	{
		cout << "quence empty, dequ failed" << endl;
		return false;
	}
}

template <class elment>
bool quence1<elment>::dequ1(elment& data)
{
	if (!empty1())
	{
		data = que[front];
		front = (front + 1) % seq_maxlength;
		flag = false;
		length--;
		return true;
	}
	else
	{
		cout << "quence empty, dequ failed" << endl;
		return false;
	}
}

template <class elment>
bool quence1<elment>::get_front(elment& data)
{
	if (!empty())
	{
		data = que[front];
		return true;
	}
	else
	{
		cout << "quence empty, get failed" << endl;
		return false;
	}
}


template <class elment>
bool quence1<elment>::get1_front(elment& data)
{
	if (!empty1())
	{
		data = que[front];
		return true;
	}
	else
	{
		cout << "quence empty, get failed" << endl;
		return false;
	}
}





/*
*使用顺序表完成队列操作
*rear下标指向队尾下标
*使用动态分配方法
*分是否牺牲存储单元完成分为带下标（不牺牲，通过增加标志位或者记录length），不带下标1（牺牲存储单元）
* 初始化时rear可初始化为seq_maxlength-1.一因为每次入队rear=（rear+1）%seq_maxlength
* 牺牲存储单元判空 （rear+1）%seq_maxlength==front   因为每次出队front=（front+1）%seq_maxlength
* 判满（rear+2）%seq_maxlength==front
*
*/
template <class elment>
class quence2
{
public:
	quence2();
	~quence2();
	bool empty();
	bool full();
	bool empty1();
	bool full1();
	int get_length();
	int get_length1();
	bool enqu(elment data);
	bool dequ(elment& data);
	bool get_front(elment& data);
	bool enqu1(elment data);
	bool dequ1(elment& data);
	bool get1_front(elment& data);
private:
	elment* que;
	int front;
	int rear;
	int length;
	bool flag;

};


template <class elment>
quence2<elment>::quence2()
{
	que = new elment[seq_maxlength];
	front = 0;
	rear = seq_maxlength - 1;
	flag = false;
	length = 0;
}


template <class elment>
quence2<elment>::~quence2()
{
	delete[] que;
}


template <class elment>
bool quence2<elment> ::empty()
{
	return (rear + 1) % seq_maxlength == front;
}

template <class elment>
bool quence2<elment> ::full()
{
	return (rear + 2) % seq_maxlength == front;
}


template <class elment>
bool quence2<elment> ::empty1()
{
	return length == 0 && ((rear + 1) % seq_maxlength == front && flag == false);
}

template <class elment>
bool quence2<elment> ::full1()
{
	return length == seq_maxlength && ((rear + 1) % seq_maxlength == front && flag == true);
}

 
template <class elment>
int quence2<elment>::get_length1()
{
	return full1() ? seq_maxlength : (rear - front + seq_maxlength + 1) % seq_maxlength;
}

template <class elment>
int quence2<elment>::get_length()
{
	return (rear - front + seq_maxlength+1) % seq_maxlength;
}

template <class elment>
bool quence2<elment>::enqu(elment data)
{
	if (!full())
	{
		rear = (rear + 1) % seq_maxlength;
		que[rear] = data;
		flag = true;
		length++;
		return true;
	}
	else
	{
		cout << "quence full, enqu failed" << endl;
		return false;
	}
}


template <class elment>
bool quence2<elment>::enqu1(elment data)
{
	if (!full1())
	{
		rear = (rear + 1) % seq_maxlength;
		que[rear] = data;
		flag = true;
		length++;
		return true;
	}
	else
	{
		cout << "quence full, enqu failed" << endl;
		return false;
	}
}


template <class elment>
bool quence2<elment>::dequ(elment& data)
{
	if (!empty())
	{
		data = que[front];
		front = (front + 1) % seq_maxlength;
		flag = false;
		length--;
		return true;
	}
	else
	{
		cout << "quence empty, dequ failed" << endl;
		return false;
	}
}

template <class elment>
bool quence2<elment>::dequ1(elment& data)
{
	if (!empty1())
	{
		data = que[front];
		front = (front + 1) % seq_maxlength;
		flag = false;
		length--;
		return true;
	}
	else
	{
		cout << "quence empty, dequ failed" << endl;
		return false;
	}
}

template <class elment>
bool quence2<elment>::get_front(elment& data)
{
	if (!empty())
	{
		data = que[front];
		return true;
	}
	else
	{
		cout << "quence empty, get failed" << endl;
		return false;
	}
}


template <class elment>
bool quence2<elment>::get1_front(elment& data)
{
	if (!empty1())
	{
		data = que[front];
		return true;
	}
	else
	{
		cout << "quence empty, get failed" << endl;
		return false;
	}
}

/*
*定义模板类节点
*注意模板类不能在使用typedef
* 声明指针应为 Lnode<elment>*
* cpp在声明结构体变量可省略struct关键字
*/
template <class elment>
struct Lnode
{
	elment date;
	Lnode* next;
};



/*
* 使用链表完成队列操作
* 不带头节点
* front rear指针初始化为NULL
* 判空front==NULL
* 入队当第一次时要将front和rear同时指向一个节点
* 其余直接操作rear指针
* 出队记得delete释放内存，同时若front==rear，还要将rear置空
*/
template <class elment>
class quence3
{
public:
	quence3();
	~quence3();
	bool empty();
	bool enqu(elment data);
	bool dequ(elment& data);
	bool get_front(elment& data);
private:
	Lnode<elment>* front;
	Lnode<elment>* rear;
};


template <class elment>
quence3<elment>::quence3()
{
	front = rear = NULL;
}

template <class elment>
quence3<elment>::~quence3()
{
	while (front != NULL)
	{
		Lnode<elment>* p = front;
		front = front->next;
		delete p;
	}
}

template <class elment>
bool quence3<elment>::empty()
{
	return front == NULL;
}


template <class elment>
bool quence3<elment>::enqu(elment data)
{
	if (empty())
	{
		front = new Lnode<elment>;
		front->next = NULL;
		front->date = data;
		rear = front;
	}
	else
	{
		Lnode<elment>* pnew = new Lnode<elment>;
		rear->next = pnew;
		pnew->date = data;
		pnew->next = NULL;
		rear = pnew;
	}
	return true;
}

template <class elment>
bool quence3<elment>::dequ(elment& data)
{
	if (empty())
	{
		cout << "quence empty, dequ failed" << endl;
		return false;
	}
	else
	{
		Lnode<elment>* p = front;
		data = front->date;
		rear = front == rear ? NULL : rear;
		front = front->next;
		delete p;
		return true;
	}
}

template <class elment>
bool quence3<elment>::get_front(elment& data)
{
	if (empty())
	{
		cout << "quence empty, get failed" << endl;
		return false;
	}
	else
	{
		data = front->date;
		return true;
	}
}


/*
* 带头结点链表完成队列操作
* 初始化front和rear指向头节点
* 入队不用特殊判断直接操作rear指针
* 判空可以用front==rear或者front->next==NULL
* 出队记得delete释放内存，同时也要给rear做特殊判断
*/
template <class elment>
class quence4
{
public:
	quence4();
	~quence4();
	bool empty();
	bool enqu(elment data);
	bool dequ(elment& data);
	bool get_front(elment& data);
private:
	Lnode<elment>* front;
	Lnode<elment>* rear;
};


template <class elment>
quence4<elment>::quence4()
{
	front = new Lnode<elment>;
	front->next = NULL;
		rear = front;
}

template <class elment>
quence4<elment>::~quence4()
{
	while (front->next != NULL)
	{
		Lnode<elment>* p = front->next;
		front->next = front->next->next;
		delete p;
	}
	delete front;
}

template <class elment>
bool quence4<elment>::empty()
{
	return front->next == NULL;//也可以是front==rear
}


template <class elment>
bool quence4<elment>::enqu(elment data)
{
		Lnode<elment>* pnew = new Lnode<elment>;
		rear->next = pnew;
		pnew->date = data;
		pnew->next = NULL;
		rear = pnew;
		return true;
}

template <class elment>
bool quence4<elment>::dequ(elment& data)
{
	if (empty())
	{
		cout << "quence empty, dequ failed" << endl;
		return false;
	}
	else
	{
		Lnode<elment>* p = front->next;
		data = p->date;
		rear = front->next == rear ? front : rear;
		front->next = p->next;
		delete p;
		return true;
	}
}

template <class elment>
bool quence4<elment>::get_front(elment& data)
{
	if (empty())
	{
		cout << "quence empty, get failed" << endl;
		return false;
	}
	else
	{
		data = front->next->date;
		return true;
	}
}

​