[Lista vinculada OJ Pregunta 8] Use pilas para implementar colas No esperaba que su hijo tuviera una base tan buena y lo hiciera bien tan rápido.

Tabla de contenido

Fuente del tema:

Código:

Análisis de ideas:

Proceso de implementación:

---

Fuente del tema:

Lituo- 232. Implementación de colas con pilas

Descripción del Título:

Código:

Nuestra pila aquí ha sido escrita. Si no conoce bien la pila, puede leer este artículo: CSDN - [Estructura de datos--Lenguaje C] Pila (pila)

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);
// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);

	ps->a = NULL;
	//ps->top = -1;//top 指栈顶数据
	ps->top = 0;//top 指栈顶数据的下一个位置
	ps->capacity = 0;
}
// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);

	if (ps->capacity == ps->top)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail:");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}

	ps->a[ps->top] = data;
	ps->top++;
}
// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	ps->top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->a[ps->top-1];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);

	if (0 == ps->top)
		return 1;
	else
		return 0;
}
// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

typedef struct {
    Stack push;
    Stack pop;
} MyQueue;

MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->push);
    StackInit(&obj->pop);

    return obj;
}

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

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

int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->pop))
    {
        while(!StackEmpty(&obj->push))
        {
            StackPush(&obj->pop, StackTop(&obj->push));
            StackPop(&obj->push);
        }
    }
    return StackTop(&obj->pop);
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->push) && StackEmpty(&obj->pop);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->push);
    StackDestroy(&obj->pop);
}

Análisis de ideas:

Conocemos las características de la cola: first in first out; las características de la pila: first in first out. Así que definimos dos pilas, una es la pila de elementos (push stack) y la otra es la pila de elementos (pop stack). Cuando queremos unirnos a la cola, colocamos los elementos directamente en la pila de inserción. Cuando salimos de la cola, primero colocamos todos los elementos de la pila de inserción en la pila emergente y extraemos los elementos superiores de la pila emergente. la pila para darse cuenta de las características de la cola.

La esencia de esta pregunta es darse cuenta de las características de la cola con las características de la pila.

Proceso de implementación:

1. Primero escribimos todas las interfaces de la pila. Luego creamos dos pilas, una es la pila que implementa la función de puesta en cola (push stack) y la otra es la pila que implementa la función de puesta en cola (pop stack);

2. Cuando queremos ingresar a la cola, colocamos los elementos en la pila de inserción. Cuando queremos salir de la cola, primero transferimos los elementos de la pila de inserción a la pila emergente y luego sacamos la pila emergente. En de esta forma, podemos darnos cuenta de que cuando salgamos de la cola, los elementos serán elemento cabeza;

3. Al salir de la cola, primero verificamos si hay elementos en la pila emergente. Si hay elementos, podemos sacar directamente el elemento superior en la pila emergente. De lo contrario, primero transfiera los elementos de la pila de inserción a la pila pop; Al ingresar al equipo, se puede ingresar directamente en la pila de empuje.

Los amigos que no sepan mucho sobre la pila pueden consultar el artículo sobre el código para implementar esa parte de la pila .

*** Fin del artículo ***