Implementación de pila en c

Podemos implementar la estructura de datos a través del lenguaje C. Hay varios tipos de estructura de datos disponible para almacenar y acceder a los datos de manera eficiente. Stack es uno de ellos.

Una pila es una versión modificada de Array. Podemos agregar o eliminar un elemento en el un extremo de la pila. Este fin está en el Arriba de la pila.

Stack es una forma especializada de manejar, almacenar, insertar, eliminar, acceder a los datos. Es de naturaleza abstracta.

Matriz y pila

1. Hay un poco de diferencia entre la matriz y la pila en términos de su accesibilidad. Podemos acceder a cualquier elemento desde la matriz en cualquier condición, pero en el caso de la pila, podemos insertar o eliminar el elemento de un extremo uno por uno. Este fin se llama Top. En términos de accesibilidad, la matriz es más rápida que la pila.
2. La pila tiene dos funciones principales llamadas push and pop.
3. La función de empuje se usa para insertar en una pila y la función POP se usa para eliminar un elemento de la pila.

Representación

Solo podemos acceder al último elemento insertado en la pila. Esta es la parte superior de la pila. Podemos insertar o quitar de la parte superior.

Esto se conoce como el último en Fast Out (LIFO) y el Fast in Last (Filo).

Implementación

La pila se puede implementar de la siguiente manera:

-> Array -> Array dinámica -> Lista de enlaces

Operación

-> Push -> Pop

Push de algoritmo: Push (pila, superior, maxstk, elemento)

1. [La pila está llena]

Si superior == maxstk

Mostrar mensaje: Desbordamiento y regreso

2. Establecer Top = Top + 1
3. Establecer pila [superior] = elemento
4. Devolver

Algoritmo Pop: Pop (pila, superior, elemento)

1. [Elemento eliminado de la pila]

Si superior == -1

Mostrar mensaje: Subflujo y regreso

2. Establecer elemento = pila [superior]
3. TOP: TOP -1
4. Devolver

Pila usando una matriz

Struct arraystack

int top;
capacidad sin firmar;
int *matriz;

Aquí, definimos un tipo de datos definido por el usuario llamado ArrayStack. Tiene tres miembros de datos llamados Top, Capacidad y un puntero llamado *Array.

Notación polaca

La notación polaca es escribir operadores de una expresión antes o después de su operando.

Formas de escritura:

Infix 2. Prefijo 3. Sufijo

Infijo

Los operadores se mantienen entre los dos operandos.

Ejemplo: A + B

Prefijo

Los operadores se mantienen antes de sus operandos.

Ejemplo: + A B

Sufijo

Los operadores se mantienen después de sus operandos.

Ejemplo: A B +

Convertir

1.

Infijo:
(A + B) * C
Prefijo:
* + A B C
Sufijo:
A B + C *

2.

Infijo:
A + (B * C)
Prefijo:
+ A B C
Sufijo:
A B C * +

3.

Infix :( A + B) / (C - D)
Prefijo:/ + a b - c d
Postfix: A B + C D - /

Toda esta conversión se puede hacer usando pila. Ahora, queremos mostrar cómo se puede crear una pila y cómo se inserta el elemento o los datos. Los elementos se pueden quitar de la pila a través de la programación.

Ejemplo de programación

#incluir
#incluir
INT ítem;
struct ArrayStack // Definir un tipo de datos;

int top;
capacidad int;
int *matriz;
;
struct arrayStack *createStack (int cap) // Crear una pila;

stact arraystack *pila;
stack = malloc (sizeOf (struct arraystack));
pila-> top = - 1;
pila-> capacidad = cap;
stack-> array = malloc (sizeOf (int) * stack-> capacidad);
return (pila);

int full (struct arraystack *stack) // comprobar la pila está completa o no.

if (stack-> top == Stack-> Capacidad-1)
retorno (1);
demás
return (0);

int vacía (struct arraystack *stack) // verificar la pila está vacía o no.

if (stack-> top == -1)
retorno (1);
demás
return (0);

Void Push (stature ArrayStack *Stack, int item) // Inserte elementos en la pila;

si ( !completa pila ) )

pila-> top ++;
pila-> array [pila-> top] = elemento;


int pop (struct arraystack *pila) // eliminar elementos de la pila;

si ( !vacío (pila))

item = Stack-> Array [Stack-> top];
pila-> top--;
Devolver objeto ) ;

return (-1);

int main ()

en la elección int;
stact arraystack *pila;
stack = createStack (4);
mientras (1)

printf ("\ n 1 . empujar " ) ;
printf ("\ n 2 . estallido " ) ;
printf ("\ n 3 . salir \ n ");
printf ("Ingrese su elección \ n");
scanf ("%d", y elección);
interruptor (elección)

caso 1:
printf ("Ingrese un número \ n");
scanf (" %d", y elemento);
Push (pila, elemento);
romper ;
Caso 2:
elemento = pop (pila);
if (item == - 1)
printf ("La pila está vacía");
demás
printf ("El valor popped es %d", elemento);
romper ;
Caso 3:
salida (0);


regresar 0;

Producción:

Explicación

Como dijimos anteriormente, definimos un tipo de datos definido por el usuario llamado ArrayStack. Tiene tres miembros de datos llamados Top, Capacidad y una matriz de puntero. Luego, definimos una función llamada createstack donde pasamos un valor que se crea el bloque total de la matriz. La función MALLOC () crea esta matriz y devuelve la dirección a la pila de variables que es el tipo ArrayStack. La matriz de pila contiene la dirección de la matriz creada por la función malloc ().

A continuación, definimos otra función llamada Full () para verificar si la pila está llena o no.

Crear otra función llamada vacía para verificar si la pila está vacía.

Luego, definimos otra función llamada Push () donde insertamos los elementos uno por uno en la pila de un extremo llamado Top. Para insertar el elemento en la pila, primero verificamos si la pila está llena.

Luego, definimos otra función llamada pop () donde eliminamos los elementos uno por uno de la pila de un extremo llamado top. Para eliminar el elemento en la pila, primero verificamos si la pila está vacía.

Luego, dentro de la función Main (), escribimos el caso de conmutación para darle al usuario una opción de menú para seleccionar su elección si el elemento está insertado o eliminado en la pila.

Conclusión

Desde la discusión sobre la pila, hemos llegado a llegar a esta conclusión de que la pila es una estructura de datos bien definida que se utiliza para administrar los datos de manera estructural. Nuestra pila de vida diaria se implementa en varios campos para almacenar, insertar o eliminar elementos.