Estructura de datos: apilar y poner en cola preguntas sobre el DO

---

Prefacio

¡Bienvenido a la clase especial de mejora!
¡La pregunta de hoy es un poco más difícil!
Pero mientras pongas tu corazón en ello, ¡no será un problema para los estudiantes!

---

1. Utilice colas para implementar pilas.

Enlace de pregunta: enlace del DO

Consejos:
1 <= x <= 9;
push, pop, top y vacío se pueden llamar hasta 100 veces;
cada vez que se llama a pop y top, se garantiza que la pila no estará vacía;

Idea central: ¡
use una cola para simular la función de primero en entrar, último en salir de hacer estallar una pila!

Ideas para resolver problemas:
este problema puede usar dos colas para implementar una pila y mantener siempre una cola vacía cada vez. La
operación de inserción es equivalente a la operación de puesta en cola de la cola no vacía, y
la operación de extracción es equivalente a la cola elemento de la cola no vacía. Quitar de la cola. En este momento, debe poner en cola los elementos restantes de la cola no vacía, excepto el último elemento, en la cola vacía, y luego sacar de la cola el último elemento al final de la cola.

Análisis de leyenda:


ejemplo de código:

Implementación de la interfaz de cola

Primero importe la interfaz de implementación de la cola.

¡Esto involucra el contenido de la creación de cola anterior!
Si no lo entiende, puede consultarlo: Apilar y poner en cola

//头文件的声明
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>


//链表接口定义
typedef int QDataType;
typedef struct QueueNode
{
    
    
	struct QueueNode* next;
	QDataType data;
}QNode;


//队列接口定义
typedef struct Queue
{
    
    
	QNode* head;
	QNode* tail;
	int size;
}Que;


//队列初始化
void QueueInit(Que* pq);
//队列销毁
void QueueDestroy(Que* pq);
//插入
void QueuePush(Que* pq, QDataType x);
//删除
void QueuePop(Que* pq);
//查找队头元素
QDataType QueueFront(Que* pq);
//查找队尾元素
QDataType QueueBack(Que* pq);
//判断是否为空
bool QueueEmpty(Que* pq);
//计算长度
int QueueSize(Que* pq);

void QueueInit(Que* pq)
{
    
    
	assert(pq);


	pq->head = pq->tail = NULL;
	pq->size = 0;
}


void QueueDestroy(Que* pq)
{
    
    
	assert(pq);


	QNode* cur = pq->head;
	while (cur)
	{
    
    
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}


	pq->head = pq->tail = NULL;
	pq->size = 0;
}


void QueuePush(Que* pq, QDataType x)
{
    
    
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
    
    
		perror("malloc fail");
		exit(-1);
	}


	newnode->data = x;
	newnode->next = NULL;


	if (pq->tail == NULL)
	{
    
    
		pq->head = pq->tail = newnode;
	}
	else
	{
    
    
		pq->tail->next = newnode;
		pq->tail = newnode;
	}


	pq->size++;
}


void QueuePop(Que* pq)
{
    
    
	assert(pq);//判断队列指针指向是否为空
	assert(!QueueEmpty(pq));//判断队列里面的数据是否为空


	if (pq->head->next == NULL)
	{
    
    
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
    
    
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}


	pq->size--;
}


//查找队头元素
QDataType QueueFront(Que* pq)
{
    
    
	assert(pq);
	assert(!QueueEmpty(pq));


	return pq->head->data;
}


//查找队尾元素
QDataType QueueBack(Que* pq)
{
    
    
	assert(pq);
	assert(!QueueEmpty(pq));


	return pq->tail->data;
}


//判断是否为空
bool QueueEmpty(Que* pq)
{
    
    
	assert(pq);


	return pq->head == NULL;
}


//长度计算
int QueueSize(Que* pq)
{
    
    
	assert(pq);


	return pq->size;
}

Definición de funciones funcionales de la pila de implementación de colas.

(1) Definición de la interfaz de pila

typedef struct {
    
    
    Que q1;
    Que q2;
} MyStack;

(2) Inicialización de la pila

MyStack* myStackCreate() {
    
    
    MyStack*pst = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);
    return pst;
}

(3) Definición de función de empuje

void myStackPush(MyStack* obj, int x) {
    
    
    if(!QueueEmpty(&obj->q1)){
    
    
        QueuePush(&obj->q1,x);
    }
    else{
    
    
        QueuePush(&obj->q2,x);
    }
}

(4) Definición de función pop

int myStackPop(MyStack* obj) {
    
    
    Que*Empty=&obj->q1;
    Que*nonEmpty=&obj->q2;
    if(!QueueEmpty(&obj->q1)){
    
    
        Empty=&obj->q2;
        nonEmpty=&obj->q1;
    }

    while(QueueSize(nonEmpty)>1){
    
    
        QueuePush(Empty,QueueFront(nonEmpty));
        QueuePop(nonEmpty);
    }

    int top = QueueFront(nonEmpty);
    QueuePop(nonEmpty);

    return top;
}

(5) Encuentra el elemento superior de la pila.

int myStackTop(MyStack* obj) {
    
    
    if(!QueueEmpty(&obj->q1)){
    
    
        return QueueBack(&obj->q1);
    }
    else{
    
    
        return QueueBack(&obj->q2);
    }
}

(6) Definición de función nula

bool myStackEmpty(MyStack* obj) {
    
    
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

(7) Definición de función de destrucción.

void myStackFree(MyStack* obj) {
    
    
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);

    free(obj);
}

2. Utilice la pila para implementar la cola.

Enlace de pregunta: enlace del DO

Consejo:
1 <= x <= 9
Un máximo de 100 llamadas para empujar, abrir, mirar y vaciar
suponiendo que todas las operaciones sean válidas (por ejemplo, una cola vacía no llamará a operaciones emergentes o de mirar)

Idea central: ¡
use la pila para simular la función de primero en entrar, primero en salir de la cola!

Ideas para resolver problemas:
este problema se puede resolver con dos pilas. Una pila realiza la operación de poner en cola y la otra pila realiza la operación de quitar la cola. La operación de quitar la cola
: cuando la pila de quitar la cola no está vacía, la operación de quitar la cola se realiza directamente. Si está vacío, la operación de eliminación de la cola se realiza directamente. , debe importar todos los elementos de la pila que están en cola a la pila que está fuera de la cola y luego realizar la operación de salida emergente.

Ejemplo de código de análisis de leyenda :

Implementación de la interfaz de pila

Primero importe la interfaz de implementación de la pila.

¡Esto implica el establecimiento de la pila anterior!
Si no lo entiende, puede consultarlo: Apilar y poner en cola

//栈的接口定义
typedef int STDataType;
typedef struct Stack
{
    
    
	STDataType* a;
	int top;
	int capacity;
}ST;


//初始化
void STInit(ST* ps);
//销毁
void STDestroy(ST* ps);
//插入
void STPush(ST* ps, STDataType x);
//删除
void STPop(ST* ps);
//查找栈顶元素
STDataType STTop(ST* ps);
//长度计算
int STSize(ST* ps);
//判断是否为空
bool STEmpty(ST* ps);

//初始化
void STInit(ST* ps)
{
    
    
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}


//销毁
void STDestroy(ST* ps)
{
    
    
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}


//插入
void STPush(ST* ps, STDataType x)
{
    
    
	assert(ps);
	if (ps->top == ps->capacity)
	{
    
    
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
    
    
			perror("realloc fail");
			exit(-1);
		}


		ps->a = tmp;
		ps->capacity = newCapacity;
	}


	ps->a[ps->top] = x;
	ps->top++;
}


//删除栈顶元素
void STPop(ST* ps)
{
    
    
	assert(ps);
	assert(ps->top > 0);
	--ps->top;
}


//查找栈顶元素
STDataType STTop(ST* ps)
{
    
    
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}


//长度计算
int STSize(ST* ps)
{
    
    
	assert(ps);


	return ps->top;
}


//判断是否为空
bool STEmpty(ST* ps)
{
    
    
	assert(ps);


	return ps->top == 0;
}

Definición de funciones funcionales de la cola de implementación de la pila.

(1) Definición de la interfaz de cola

typedef struct {
    
    
    ST pushst;
    ST popst;
} MyQueue;

(2) Inicialización de la cola

MyQueue* myQueueCreate() {
    
    
    MyQueue*obj = (MyQueue*)malloc(sizeof(MyQueue));
    STInit(&obj->pushst);
    STInit(&obj->popst);
    return obj;
}

(3) Definición de función de cola

void myQueuePush(MyQueue* obj, int x) {
    
    
    STPush(&obj->pushst,x);
}

(4) Definición de función de salida de cola

int myQueuePop(MyQueue* obj) {
    
    
    int front = myQueuePeek(obj);
    STPop(&obj->popst);
    return front;
}

(5) Encuentre la definición de la función del jefe de equipo.

int myQueuePeek(MyQueue* obj) {
    
    
    if(STEmpty(&obj->popst))
    {
    
    
        while(!STEmpty(&obj->pushst)){
    
    
            STPush(&obj->popst,STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }
    return STTop(&obj->popst);
}

(6) Definición de función nula

bool myQueueEmpty(MyQueue* obj) {
    
    
    return STEmpty(&obj->popst)&&STEmpty(&obj->pushst);
}

(7) Definición de función de destrucción.

void myQueueFree(MyQueue* obj) {
    
    
    STDestroy(&obj->popst);
    STDestroy(&obj->pushst);

    free(obj);
}

3. Diseñar cola circular

Enlace de pregunta: enlace del DO

Consejo:
Todos los valores estarán en el rango de 0 a 1000;
los operandos estarán en el rango de 1 a 1000;
no utilice la biblioteca de colas integrada.

Idea central: ¡
Un bucle conectado de un extremo a otro es un anillo!

Idea de resolución de problemas:
implementar la
cola : primero determine si la cola está llena y luego realice la operación de puesta en cola. La operación de puesta en cola debe considerar el problema del bucle de índice. Cuando el índice está fuera de los límites, debe minimizarse. Valor
Quitar de la cola: Primero, debe determinar si la cola está vacía y luego realizar la operación de quitar la cola. Quitar la cola también necesita considerar el problema del bucle de índice. Juicio vacío
: Cabeza de cola == Cola de cola.
Juicio completo : Cola de cola + 1 == Cabeza de cola.

Análisis de leyenda:



ejemplo de código:

(1) Definición de interfaz de cola circular

typedef struct {
    
    
    int *a;
    int front;
    int rear;
    int k;
} MyCircularQueue;

(2) Inicialización de cola circular

MyCircularQueue* myCircularQueueCreate(int k) {
    
    
    MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));

    obj->a=(int*)malloc(sizeof(int)*(k+1));
    obj->front=obj->rear=0;
    obj->k=k;
    return obj;
}

(3) Definición de función nula

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    
    
    return obj->front==obj->rear;
}

(4) Definición de función completa

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    
    
    return (obj->rear+1)%(obj->k+1)==obj->front;
}

(5) Definición de función de inserción de cola circular

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    
    
    if(myCircularQueueIsFull(obj))
        return false;
    
    obj->a[obj->rear]=value;
    obj->rear++;
    obj->rear%=(obj->k+1);
    return true;
}

(6) Definición de función de eliminación de cola circular

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    
    
    if(myCircularQueueIsEmpty(obj))
        return false;
    ++obj->front;
    obj->front%=(obj->k+1);
    return true;
}

(7) Encuentre la definición de la función del jefe de equipo.

int myCircularQueueFront(MyCircularQueue* obj) {
    
    
    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
        return obj->a[obj->front];
}

(8) Encuentre la definición de la función de cola.

int myCircularQueueRear(MyCircularQueue* obj) {
    
    
    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
        return obj->a[(obj->rear+obj->k)%(obj->k+1)];
}

(9) Definición de función de destrucción.

void myCircularQueueFree(MyCircularQueue* obj) {
    
    
    free(obj->a);
    free(obj);
}

---

Resumir

¡La pregunta de hoy es realmente difícil!
¡Pero también cree en ti mismo!
¡La confianza es la mejor manera de resolver problemas!