队列的C++实现

队列是具有一定操作约束的线性表。只能在一端插入，在另一端删除

队列的顺序存储

#include<iostream>
using namespace std;
#define Max_size 10
class queue_m {
public:
	queue_m(){
		rear = front = 0;
	}
	void add_elem(int val);//在队尾添加元素
	int pop_elem();//将队头元素从列表中删除并返回
	void show_m();//显示队列中的所有元素
	bool IsEmpty();//判断队列是否为空
	bool IsFull();//判断队列是否满了

private:
	int rear;
	int front;
	int data[Max_size];
};
void queue_m::add_elem(int val) {
	if (this->IsFull())
	{
		cout << "队列已满，无法再进行添加" << endl;
		return;
	}
	rear = (rear + 1) % Max_size;
	data[rear ] = val;
	
}
int queue_m::pop_elem() {
	if (this->IsEmpty())
	{
		cout << "队列为空，无法再进行删除" << endl;
		return -1;
	}

	front= (front + 1) % Max_size;
	return data[front];
}
void queue_m::show_m(){
	int temp = front;
	while (temp != rear)
	{
		temp = (temp + 1) % Max_size;
		cout << data[temp] << endl;
	}

}
bool queue_m:: IsEmpty() {
	if (rear == front) {
		return true;
	}
	else
		return false;
}
 
bool queue_m::IsFull() {
	if ((rear+1)% Max_size == front) {
		return true;
	}
	else
		return false;
}
int main() {
	queue_m my_queue;
	my_queue.add_elem(3);
	my_queue.add_elem(4);
	my_queue.show_m();
	int m = my_queue.pop_elem();
	cout << m << endl;
	my_queue.show_m();

	return 0;

}

队列的链式实现

#include<iostream>
using namespace std;
#define Max_size 10
class node {
public:
	friend class queue_m;
private:
	int value;
	node* pnext;
};
class queue_m {
public:
	queue_m(){
		front=new node();
		front->pnext = NULL;
		rear = front;
	}
	void add_elem(int val);//在队尾添加元素
	int pop_elem();//将队头元素从列表中删除并返回
	void show_m();//显示队列中的所有元素
	bool IsEmpty();//判断队列是否为空
	void clear();//释放在堆区申请的内存

private:
	node *rear;
	node *front;
};
void queue_m::add_elem(int val) {
	node* pnew = new node();
	pnew->pnext = NULL;
	pnew->value = val;
	rear->pnext = pnew;
	rear = rear->pnext;
	
	
}
int queue_m::pop_elem() {
	if (this->IsEmpty())
	{
		cout << "队列为空，无法再进行删除" << endl;
		return -1;
	}
	node*temp = front;
	front = front->pnext;
	delete temp;
	return front->value;
}
void queue_m::show_m(){
	node* temp = front;
	while (temp != rear)
	{
		temp = temp->pnext;
		cout << temp->value << endl;
	}

}
bool queue_m:: IsEmpty() {
	if (rear == front) {
		return true;
	}
	else
		return false;
}
void queue_m::clear() {
	while (front->pnext!=NULL) {
		node* temp = front;
		front = front->pnext;
		delete temp;

	}
	delete front;
}

int main() {
	queue_m my_queue;
	my_queue.add_elem(3);
	my_queue.add_elem(4);
	my_queue.show_m();
	int m = my_queue.pop_elem();
	cout << m << endl;
	my_queue.show_m();

	return 0;

}

队列实现两个多项式相加

例3x^3-14x^2+5x与3x^4+4x^3+5x^2相加

#include<iostream>
//#include<alogrithem>
using namespace std;
#define Max_size 10
class node {
public:
	friend class queue_m;
private:
	int value;
	int mi;
	node* pnext;
};
class queue_m {
public:
	queue_m(){
		front=new node();
		front->pnext = NULL;
		rear = front;
	}
	void add_elem(int val,int n);//在队尾添加元素
	int pop_elem();//将队头元素从列表中删除并返回
	void show_m();//显示队列中的所有元素
	bool IsEmpty();//判断队列是否为空
	void reverse_m();//队列的反转
	void clear();//释放在堆区申请的内存
	void operator+(const queue_m&b);
private:
	node *rear;
	node *front;
	
};

void queue_m::operator+(const queue_m&b) {
	node*p1=this->front->pnext;
	node*p2 = b.front->pnext;
	queue_m ans;
	node*pre = new node();
	node*temp = pre;
	pre->pnext = NULL;
	while (p1&&p2) {
		node*pnew = new node();
		if (p1->mi == p2->mi) {
			pnew->value = p1->value + p2->value;
			pnew->mi = p2->mi;
			p1 = p1->pnext;
			p2 = p2->pnext;
		}
		else if (p1->mi > p2->mi) {
			pnew->value = p1->value;
			pnew->mi = p1->mi;
			p1 = p1->pnext;

		}
		else if (p1->mi < p2->mi) {
			pnew->value = p2->value;
			pnew->mi = p2->mi;
			p1 = p2->pnext;
		}
		pre->pnext = pnew;
		pre = pnew;
		
	}
	if (p1)
		pre->pnext = p1;
	if(p2)
		pre->pnext = p2;
	node*p = temp->pnext;
	cout << "相加之后的值为" << endl;
	while (p) {
		cout << p->value << ',' << p->mi << endl;
		p = p->pnext;
	}
}

void queue_m::add_elem(int val,int n) {
	node* pnew = new node();
	pnew->pnext = NULL;
	pnew->value = val;
	pnew->mi = n;
	rear->pnext = pnew;
	rear = rear->pnext;
	
	
}
int queue_m::pop_elem() {
	if (this->IsEmpty())
	{
		cout << "队列为空，无法再进行删除" << endl;
		return -1;
	}
	node*temp = front;
	front = front->pnext;
	delete temp;
	return front->value;
}
void queue_m::show_m(){
	node* temp = front;
	while (temp != rear)
	{
		temp = temp->pnext;
		cout << temp->value<<','<<temp->mi << endl;
	}

}
bool queue_m:: IsEmpty() {
	if (rear == front) {
		return true;
	}
	else
		return false;
}
void  queue_m::reverse_m() {

	node*temp = front->pnext;
	node *new_rear = temp;
	node*pre=NULL;
	while (temp!=NULL) {
		node* next = temp->pnext;
		temp->pnext = pre;
		pre = temp;
		temp = next;
		
	}
	node*head = new node();
	head->pnext = pre;
	rear = new_rear;
	front = head;
	
}

void queue_m::clear() {
	while (front->pnext!=NULL) {
		node* temp = front;
		front = front->pnext;
		delete temp;

	}
	delete front;
}

int main() {
	queue_m my_queue0;
	queue_m my_queue1;
	my_queue0.add_elem(3,3);
	my_queue0.add_elem(-14,2);
	my_queue0.add_elem(5,1);
	my_queue0.show_m();
	my_queue1.add_elem(3, 4);
	my_queue1.add_elem(4, 3);
	my_queue1.add_elem(5, 2);
	my_queue1.show_m();
	node*p = new node();
	my_queue1 + my_queue0;
	
	return 0;

}