[Estructura de datos] Pila detallada

El concepto de pila y su estructura.

Pila: un tipo especial de lista lineal que solo permite la inserción y eliminación de elementos en un extremo fijo. Un extremo que realiza operaciones de inserción y eliminación de datos se denomina parte superior de la pila y el otro extremo se denomina parte inferior de la pila.

Los elementos siguen el principio LIFO .

Empujar la pila: la inserción de la pila se llama empujar/empujar/empujar, y los datos empujados están en la parte superior de la pila.

Pop: La operación de borrado de la pila se llama pop. Los datos de salida están en la parte superior de la pila.

Implementación de pila

La pila generalmente se puede implementar con una matriz o una lista enlazada, y la estructura de la matriz es relativamente mejor.

 

La implementación de la pila generalmente se implementa mediante la gestión de memoria dinámica.

 

准备环节：

//以顺序表的形式
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;//栈顶
	int capacity;//容量
}Stack;

1. Inicialización

Idea básica: 1) Afirmaciones

2) El puntero está vacío

3) La parte superior de la pila, la capacidad se establece en 0

Código:

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

2. Empuje la pila

Idea básica: 1) Afirmaciones

2) Determinar si la tabla de secuencia necesita expandirse

3) Insertar datos

Dibujo:

Inserción de cola similar a la tabla de secuencia

Código:

//入栈
void StackPush(Stack* ps, STDataType x)
{
	//断言
	assert(ps);
	//判断是否需要扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? ps->capacity = 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
		//判断扩容是否成功
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	//插入数据
	//数组的下标从0开始，top指向的就是栈顶
	ps->a[ps->top] = x;
	ps->top++;
}

 

3. Explota la pila

Idea básica: similar a la eliminación de cola de lista secuencial

1) Afirmación

2) Poner la parte superior--, solo retroceder un lugar

Dibujo:

Código:

//出栈
void StackPop(Stack* ps)
{
	assert(ps);
	//断言栈是否为空
	assert(ps->top > 0);

	ps->top--;
}

 

4. Obtenga el elemento superior de la pila

Idea básica: 1) Afirmaciones

2) Comprobar si la pila está vacía

3) Volver ps->a[ps->top-1]

Dibujo:

Se puede ver que top apunta al siguiente bit del elemento superior de la pila.

Código:

//获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	//断言栈是否为空
	assert(ps->top);

	return ps->a[ps->top-1];
}

 

5. Comprueba si la pila está vacía

Devuelve verdadero si está vacío Devuelve falso si no está vacío

Idea básica: 1) Afirmar el puntero pasado

2) Si sentencia sentencia o devuelve el resultado de ps->top == 0

Código:

//检测栈是否为空
bool StackEmpty(Stack* ps)
{
	assert(ps);
	非空
	//if (ps->top > 0)
	//{
	//	return false;
	//}
	为空
	//else
	//	return true;
	//更优化的写法
	return ps->top == 0;
}

6. Registre la cantidad de datos en la pila

Idea básica: 1) Afirmaciones

2) El valor de top se refiere al número de datos.

Dibujo:

 

En este momento, el número de datos de la pila es 3 y el valor de la parte superior es 3.

Código:

int StackSize(Stack* ps)
{
	assert(ps);
	//返回个数，top指的是栈顶数据的下一位。
	return ps->top;
}

 

7. Destruye la pila

Idea básica: 1) Afirmaciones

2) variable de puntero libre

3) La capacidad y la parte superior de la pila se establecen en 0

Código:

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

Imprimir datos de pila contra interfaces conocidas

#include"Stack.h"

void test()
{
	Stack st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);

	//printf("%d ", StackTop(&st));

	while (!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}
	printf("\n");

	StackDestroy(&st);
}
int main()
{
	test();
	return 0;
}

Archivo principal:

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>

//以顺序表的形式
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;//栈顶
	int capacity;//容量
}Stack;

//初始化
void StackInit(Stack* ps);

//销毁
void StackDestroy(Stack* ps);

//入栈
void StackPush(Stack* ps,STDataType x);

//出栈
void StackPop(Stack* ps);

//获取栈顶元素
STDataType StackTop(Stack* ps);

//检测栈是否为空
bool StackEmpty(Stack* ps);

//获取栈有多少个数据
int StackSize(Stack* ps);