contenido
El concepto y la estructura de la pila.
Comprobar si la pila está vacía
acceder al elemento superior de la pila
El concepto y la estructura de la pila.
Un tipo especial de tabla lineal que permite la inserción y eliminación de elementos solo en un extremo fijo. Un extremo donde se realizan la 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 en la pila siguen el principio de último en entrar, primero en salir.
( Mesa lineal con un extremo cerrado )
Empujar pila: La operación de 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 eliminación de la pila se llama pop. Los datos salientes también están en la parte superior de la pila
icono
analizar
La pila es una lista lineal, que se implementa mejor con matrices dinámicas.
Debe desarrollarse dinámicamente y es necesario registrar el número de elementos válidos, la capacidad del espacio y la posición de la parte superior de la pila.
Puede consultar la tabla de secuencias para comprender : la implementación de la tabla de secuencias: se busca programador
Implementación de pila
definición
La posición inicial, la posición superior de la pila (operando con subíndices) y la capacidad.
typedef struct Stack
{
Datatype* a;
int top; //栈顶位置
int capacity; //容量
}ST;inicialización
La posición inicial está vacía, la capacidad es 0 y la parte superior de la pila está en la posición del subíndice 0.
//初始化
void StackInit(ST* ps)
{
assert(ps);
ps->a = NULL;
ps->capacity = 0;
ps->top = 0;
}destruir
Suelte desde la posición inicial, porque el espacio se abre continuamente, liberar la posición inicial liberará todo el espacio abierto
capacidad y pila superior 0
//销毁
void StackDestory(ST* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = ps->top = 0;
}empujar la pila
Después de la afirmación, primero debe verificar si la capacidad es suficiente. Si el espacio no es suficiente, necesita reasignar espacio. Si el espacio es insuficiente, le dará 4 tipos de datos de espacio. Si no es igual a 0, se le dará el doble del tamaño del espacio existente.
Una vez resuelto el espacio, almacene los datos y actualice la parte superior de la pila.
//压栈
void StackPush(ST* ps, Datatype x)
{
assert(ps);
if (ps->top == ps->capacity)
{
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
ps->a = realloc(ps->a, newcapacity*sizeof(Datatype));
if (ps->a == NULL)
{
printf("realloc fail\n");
exit(-1);
}
ps->capacity = newcapacity;
}
ps->a[ps->top] = x;
ps->top++;
}estallido
Cabe señalar que no solo se debe afirmar ps, sino que también la parte superior de la pila debe ser mayor que 0, es decir, la pila no está vacía.
Debido a que el espacio abierto es continuo y no se puede liberar por separado, podemos actualizar directamente la parte superior de la pila.
//出栈
void StackPop(ST* ps)
{
assert(ps);
assert(ps->top>0);
ps->top--;
}Comprobar si la pila está vacía
Devuelve verdadero si está vacío, devuelve falso si no está vacío
//判断栈是否为空
bool StackEmpty(ST* ps)
{
assert(ps);
//if (ps->top > 0)
//{
// return false;
//}
//else
//{
// return true;
//}
return ps->top == 0;
}número de datos
El número de datos es directamente el subíndice de la parte superior de la pila
//数据个数
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}acceder al elemento superior de la pila
El elemento superior de la pila es el anterior a la parte superior de la pila, y top-1 es el subíndice del elemento superior de la pila.
//访问栈顶数据
Datatype StackTop(ST* ps)
{
assert(ps);
return ps->a[ps->top-1];
}archivo principal
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
typedef int Datatype;
typedef struct Stack
{
Datatype* a;
int top; //栈顶位置
int capacity; //容量
}ST;
void StackInit(ST* ps);
void StackDestory(ST* ps);
void StackPush(ST* ps,Datatype x);
void StackPop(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);
//数据个数
int StackSize(ST* ps);
//访问栈顶数据
Datatype StackTop(ST* ps);archivo de prueba
#include "Stack.h"
void TestStack()
{
ST st;
StackInit(&st);
StackPush(&st,1);
StackPush(&st, 2);
StackPush(&st, 3);
StackPush(&st, 4);
StackPush(&st, 5);
while (!StackEmpty(&st))
{
printf("%d ",StackTop(&st));
StackPop(&st);
}
StackDestory(&st);
}
int main()
{
TestStack();
return 0;
}Todavía puede empujar y abrir la pila de acuerdo con sus propias necesidades, ¡y se implementa la pila simple! !
