数据结构期末拯救计划：队列

队列也是一种典型的数据存储结构，遵循先进先出的原则队尾进元素，队头删元素，下面看看它的基本操作

#include<iostream>
using namespace std;
typedef struct qnode
{
	int data;
	qnode* next;
}qnode;
typedef struct queue
{
	qnode* head;
	qnode* tail;
	int size;
}queue;
void init(queue* point)
{
	point->head = point->tail = nullptr;
	point->size = 0;
}
void push(queue* point, int x)
{
	qnode* root = new qnode;
	root->data = x;
	root->next = nullptr;
	if (point->head == nullptr)
	{
		point->head = point->tail = root;
		point->size++;
	}
	else
	{
		point->tail->next = root;
		point->tail = root;
		point->size++;
	}
}
void pop(queue* point)
{
	if (point->head != nullptr)
	{
		qnode* root1 = point->head;
		point->head = root1->next;
		delete root1;   
		point->size--;   
	}
}
int size(queue* point)
{
	return point->size;
}
bool empty(queue* point)
{
	return point->head == nullptr;
}

2.栈和队列的配套操作，也是我压的一道题

【问题描述】已知Q是一个非空队列，S是一个空栈。仅使用少量工作变量以及对队列和栈的基本操作，编写一个算法，将队列Q中的所有元素逆置。需采用链式队列与栈（顺序或链式），否则不能得分。

【输入形式】输入的第一行为队列元素个数，第二行为队列从首至尾的元素

【输出形式】输出队列的逆置

【样例输入】

3

1 2 3

【样例输出】

3 2 1

题目整体思路：将元素入栈，遵循先进后出的原则，再存储到队列中，此时存储顺序变为3，2，1，而队列遵循先进先出的原则，输出时也是1，2，3，利用这个性质，我们也可以实现两个栈实现队列以及两个队列实现栈的操作

#include<iostream>
#include<stack>
using namespace std;
typedef struct qnode
{
	int data;
	qnode* next;
}qnode;
typedef struct queue
{
	qnode* head;
	qnode* tail;
	int size;
}queue;
void init(queue* point)
{
	point->head = point->tail = nullptr;
	point->size = 0;
}
void push(queue* point, int x)
{
	qnode* root = new qnode;
	root->data = x;
	root->next = nullptr;
	if (point->head == nullptr)
	{
		point->head = point->tail = root;
		point->size++;
	}
	else
	{
		point->tail->next = root;
		point->tail = root;
		point->size++;
	}
}
void pop(queue* point)
{
	if (point->head != nullptr)
	{
		qnode* root1 = point->head;
		point->head = root1->next;
		delete root1;   
		point->size--;   
	}
}
int size(queue* point)
{
	return point->size;
}
bool empty(queue* point)
{
	return point->head == nullptr;
}
void judge(queue* q)
{
	stack<int>st;
	while (!empty(q))
	{
		int front = q->head->data;
		pop(q);
		st.push(front);
	}
	while (!st.empty())
	{
		push(q, st.top());
		st.pop();
	}
}
int getfront(queue* q)
{
	return q->head->data;
}
int main()
{
	queue q;
	init(&q);
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		int x;
		cin >> x;
		push(&q, x);
	}
	judge(&q);
	while (!empty(&q))
	{
		cout << getfront(&q) << ' ';
		pop(&q);
	}
	return 0;
}

3，循环队列打印杨辉三角形，由于上学期打印过，所以这次也容易考

【问题描述】杨辉三角形的打印，请用循环队列实现。不采用“循环队列”，不给分。

【样例输入】

4
【样例输出】

1

1 1

1 2 1

1 3 3 1

循环队列存储在一个结构体中，结构体底层是一个数组，注意手法，将此结构体的本名写出的前提情况下，需要给出typedef的指针写法以便在初始化队列的过程中给这个结构体分配内存，由于是循环队列，在入队列，出队列时与普通队列的指针移动不同，需要除结构体数组长度，而主函数打印杨辉三角的操作思路如下，首先让一个1入队，因为第一行永远是1，并将这个1入队，然后如果是第2行及以下，则设置两个记录变量t1,t2，然后打印每行的n个元素，把t2的值给t1，然后把t2的值更新为出队列的值，让x再入队列，并输出，在内层循环后，输出不参与计算的结尾1，并将x初始化为1并入队列

#include<iostream>
using namespace std;
typedef struct sq
{
    int a[500];
    int front;
    int rear;
}*queue;
queue init()
{
    queue q;
    q = new sq;
    q->front = q->rear = 0;
    return q;
}
void enter(queue q, int x)
{
    q->a[q->rear] = x;
    q->rear = (q->rear + 1) % 500;
}
int outqueue(queue q)
{
    int x;
    if (q->front == q->rear)
    {
        return 0;
    }
    x = q->a[q->front];
    q->front = (q->front + 1) % 500;
    return x;
}
int main() {
    queue q;
    int x = 1, i;

    cin >> i;
    q = init();
    for (int n = 0; n < i; n++)
    {

        if (n == 0)
        {
            cout << 1 << endl;
            enter(q, x);
        }
        else
        {
            int t1 = 0, t2 = 0;
            for (int r = 0; r < n; r++)
            {
                t1 = t2;
                t2 = outqueue(q);
                x = t1 + t2;
                enter(q, x);
                cout << x << " ";
            }
            cout << 1 << endl;
            x = 1;
            enter(q, x);
        }
    }
    return 0;
}