Pila de estructura de datos (lenguaje C)

descarga de código github

código github:
https://github.com/Kyrie-leon/Data_Structures/tree/main/stack_queue

1. El concepto y la estructura de la pila

Pila : Una forma lineal especial, en la que solo un extremo se fija para las operaciones de inserción y eliminación de elementos.Un extremo de las 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 de datos de la pila obedecenLIFO (último en entrar, primero en salir)en principio.
Empujar : La operación de insertar la pila se llama empujar / empujar / empujar,Los datos entrantes están en la parte superior de la pila.
Pop : la operación de eliminación de la pila se llama pop.Los datos también están en la parte superior de la pila.。

En segundo lugar, la implementación de la pila

La implementación de la pila generalmente se puede implementar usando una matriz o una lista enlazada , y la estructura de la matriz es relativamente mejor. Debido a que la matriz está enEl costo de insertar datos en la cola es relativamente pequeño,Como se muestra abajo.

Sin embargo, si se utiliza la siguiente estructura para implementar la pila, la inserción de la cola debe mover los datos , lo que genera una gran sobrecarga computacional.

2.1 Definición de almacenamiento en pila

La pila de almacenamiento estático se implementa
utilizando una matriz unidimensional estática a [N], pero al hacerlo, se desperdiciará demasiado espacio o no habrá espacio suficiente

#define N 10
typedef int STDataType;
typedef struct Stack Stack;
struct Stack
{
    
    
	STDataType a[N];
	int _top;	//栈顶
};

Admite el crecimiento dinámico de la pila
Utilice un puntero _a para abrir dinámicamente la memoria para lograr el almacenamiento de la pila

typedef int STDataType;
typedef struct Stack Stack;
//支持动态增长的栈
struct Stack
{
    
    
	STDataType * _a;
	int _top;			//栈顶
	int _capacity;		//容量
};

2.2 Inicialización de la pila

Inicialización: de forma predeterminada, se abren cuatro espacios del tamaño de STDataType para la pila

• capacidad: la capacidad de la pila , por defecto 4
• _top: indica la parte superior de la pila . Estamos de acuerdo en que _top = 0 significa que la pila está vacía. Después de eso, _top aumentará en 1 por cada elemento empujado a la pila.Es decir, la siguiente tabla de la matriz apuntada por _top es siempre 1 más grande que el subíndice del elemento superior de la pila real

//栈的初始化
void StackInit(Stack * ps)
{
    
    
	assert(ps);
	ps->_a = (STDataType *)malloc(sizeof(Stack) * 4);	//默认数组大小为4
	ps->_top = 0;		//栈为空，则栈顶为0
	ps->_capacity = 4;	//默认栈的容量为4
}

2.3 Empujar en la pila

Se acordó que la siguiente tabla de la matriz apuntada por _top es siempre 1 más grande que el índice del elemento superior de la pila real.
Solo necesita almacenar los datos en la matriz de _top index y luego agregar 1 a _top

//入栈
void StackPush(Stack * ps, STDataType data)
{
    
    
	assert(ps);
	//判断栈是否满了，满了则增容
	if (ps->_top == ps->_capacity)
	{
    
    
		ps->_capacity *= 2;	//每次扩容2倍
		STDataType * tmp = (STDataType *)realloc(ps->_a, sizeof(Stack)*ps->_capacity);
		//判断内存是否申请成功
		if (NULL == tmp)
		{
    
    
			printf("扩容失败\n");
			exit(-1);
		}
		ps->_a = tmp;
	}
	//入栈
	ps->_a[ps->_top] = data;	
	ps->_top++;
}

2.4 Pop

La siguiente tabla de la matriz apuntada por _top es siempre 1 mayor que el subíndice del elemento superior de la pila real
Por lo tanto, solo necesita reducir _top en 1.

//出栈
void StackPop(Stack * ps)
{
    
    
	assert(ps);
	assert(ps->_top>0);
	ps->_top--;
}

2.5 Obtener el elemento superior de la pila

La siguiente tabla de la matriz apuntada por _top es siempre 1 mayor que el subíndice del elemento superior de la pila real
Entonces, el subíndice del elemento superior de la pila es _top-1

//获取栈顶元素
STDataType StackTop(Stack *ps)
{
    
    
	assert(ps);
	assert(ps->_top>0);

	return ps->_a[ps->_top-1];	
}

2.6 Obtenga el número de elementos válidos en la pila

Debido a que el índice del elemento de la matriz comienza en 0, _top representa el número de elementos válidos en la pila

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

2.7 Compruebe si la pila está vacía

El valor de _top se puede utilizar para determinar si la pila está vacía.
Si _top es 0, significa que está vacío.
Si _top es 1, significa que no está vacío. Si _top es 1, significa que no está vacío. Si es negativo, devuelve 0.

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

2.8 Destruye la pila

//销毁栈
void StackDestory(Stack * ps)
{
    
    
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}

Tres, prueba de pila

#include "stack.h"

void TestStack()
{
    
    
	Stack ps;
	StackInit(&ps);
	StackPush(&ps, 1);
	StackPush(&ps, 2);
	StackPush(&ps, 3);
	StackPush(&ps, 4);
	StackPush(&ps, 5);
	while (!StackEmpty(&ps))
	{
    
    

		printf("%d, %d\n", StackTop(&ps),StackSize(&ps));
		StackPop(&ps);
	}

	
}

int main()
{
    
    
	TestStack();
	system("pause");
	return 0;
}

Cuarto, la lista de códigos

4.1 pila.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<windows.h>

#define N 10
typedef int STDataType;
typedef struct Stack Stack;
//struct Stack
//{
    
    
//	STDataType a[N];
//	int _top;	//栈顶
//};

//支持动态增长的栈
struct Stack
{
    
    
	STDataType * _a;
	int _top;			//栈顶
	int _capacity;		//容量
};

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

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

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

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

//获取栈顶中有效元素个数
int StackSize(Stack * ps);

//检测栈是否为空，如果为空返回非0，不为空返回0
int StackEmpty(Stack* ps);

//销毁栈
void StackDestory(Stack * ps);

4.2 pila.c

#include "stack.h"

//栈的初始化
void StackInit(Stack * ps)
{
    
    
	assert(ps);
	ps->_a = (STDataType *)malloc(sizeof(Stack) * 4);	//默认数组大小为4
	ps->_top = 0;		//栈为空，则栈顶为0
	ps->_capacity = 4;	//默认栈的容量为4
}

//入栈
void StackPush(Stack * ps, STDataType data)
{
    
    
	assert(ps);
	//判断栈是否满了，满了则增容
	if (ps->_top == ps->_capacity)
	{
    
    
		ps->_capacity *= 2;	//每次扩容2倍
		STDataType * tmp = (STDataType *)realloc(ps->_a, sizeof(Stack)*ps->_capacity);
		//判断内存是否申请成功
		if (NULL == tmp)
		{
    
    
			printf("扩容失败\n");
			exit(-1);
		}
		ps->_a = tmp;
	}
	//入栈
	ps->_a[ps->_top] = data;	
	ps->_top++;
}

//出栈
void StackPop(Stack * ps)
{
    
    
	assert(ps);
	assert(ps->_top>0);
	ps->_top--;
}

//获取栈顶元素
STDataType StackTop(Stack *ps)
{
    
    
	assert(ps);
	assert(ps->_top>0);

	return ps->_a[ps->_top-1];	
}

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

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

//销毁栈
void StackDestory(Stack * ps)
{
    
    
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}

4.3 prueba.c

#include "stack.h"

void TestStack()
{
    
    
	Stack ps;
	StackInit(&ps);
	StackPush(&ps, 1);
	StackPush(&ps, 2);
	StackPush(&ps, 3);
	StackPush(&ps, 4);
	StackPush(&ps, 5);
	while (!StackEmpty(&ps))
	{
    
    

		printf("%d, %d\n", StackTop(&ps),StackSize(&ps));
		StackPop(&ps);
	}

	
}

int main()
{
    
    
	TestStack();
	system("pause");
	return 0;
}