Andrade Palacios Luis Ulises Pilas

Pila. Elabora el código para los siguientes problemas.

1. Implementa las operaciones de una pila de máximo diez elementos de tipo
cadena que permita almacenar los colores introducidos por el usuario,
mediante menú:
a. Insertar
b. Eliminar
c. Consultar
d. Salir
CODIGO:

1 struct Nodo{
2 char Color[15];
3 struct Nodo *ant, *sig;
4 }
5 struct Nodo *Lc, *Nuevo;
6 main(){
7 Inicializar();
8 do{
9 puts (“1. Insertar 2. Desplegar Inicio-Fin 3.
10 DesplegarFinal-Inicio 4. Salir”);
11 scanf (“%d”, &op);
12 switch (op){
13 case 1: puts (“Color: “);
14 gets (Color);
15 InsertarFinal(Color);
16 case 2: DesplegarIF();
17 case 3: DesplegarFI();
18 }
19 }while (op < 4)
20 }
21 void Inicializar(){
22 Lc = NULL;
23 }
24 void InsertarFinal(char Color[15]){
25 Nuevo = (struct Nodo *) malloc(sizeof(struct Nodo));
26 strcpy(Nuevo->Color, Color);
27 if (Lc == NULL) {
28 Nuevo->ant = Nulo;
29 Nuevo->sig = Nulo;
30 }
31 else{
32 Nuevo->ant = Lc;
33 Nuevo->sig = Lc->sig;
34 }
35 Lc = Nuevo;
Andrade Palacios Luis Ulises Pilas

36 }
37 void DesplegarIF(){
38 Aux = Lc->sig;
39 while(Aux <> Lc){
40 printf (“%s/n”, Aux ->Color);
41 Aux = Aux->sig;
42 }
43 }
44 void DesplegarFI(){
45 Aux = Lc;
46 while(Aux <> Lc->sig){
47 printf(“%s/n”, Aux ->Color);
48 Aux = Aux->ant;
49 }
50 printf(“%s/n”, Aux ->Color);
51 }

2. Llena una pila de 15 elementos de tipo entero que sean generados

aleatoriamente, desplegar la pila mediante un menú:
a. Insertar
b. Eliminar
c. Tope
d. Salir

CODIGO:
1 struct Pila{
2 char Datos[5][30];
3 int Fr;
4 int Fi;
5 };
6 struct Pila C;
7 void inicializa(), Insertar(int), Eliminar(),Desplegar();
8 int PilaLlena(), PilaVacia();
9 main(){
10 int Op, Num;
11 Inicializa();
12 do{
13 puts(“a. Insertar b. Eliminar c. Desplegar d.
14 Salir”)
15 scanf(“%d”, &op);
16 switch (op){
17 case ´a´: Num = srandom();
18 Insertar(Num);
19 case ´b´: Eliminar();
20 case ´c´: Desplegar();
21 }
Andrade Palacios Luis Ulises Pilas

22 }while (Op ¡= 3);

23 }
24 void Inicializa (){
25 C.Fr = -1;
26 C.Fi = -1;
27 }
28 void Insertar (int Num){
29 if (PilaLlena() ¡= 1) {
30 C.Fi = C.Fi+1;
31 C.Datos[C.Fi] = Num;
32 if (C.Fr == -1) C.Fr = 0;
33 }
34 else{
35 puts (“Pila llena”);
36 }
37 }
38 int PilaLlena ()
39 {
40 if (C.Fi == 9) return 1;
41 else return 0;
42 }
43 void Eliminar(){
44 if (PilaVacia() ¡= 1) C.Fr = C.Fr+1;
45 else printf (“Pila Vacia”);
46 }
47 int PilaVacia(){
48 if (C.Fi=-1 y C.Fr=-1) || (C.Fi < C.Fr) return 1;
49 else return 0;
50 }
51 void Desplegar(){
52 printf (“Frente: %d”, C.Datos[C.Fr]);
53 printf (“Final: %d”, C.Datos[C.Fi]);
54 }

3. Implementa las operaciones de una pila de máximo 10 elementos.

a. La operación Insertar, inserta elementos de tipo entero generados
aleatoriamente.
b. La operación Tope despliega el elemento que se encuentra en el Tope de
la pila

CODIGO:
1 #include <stdio.h>
2 struct Pila{
3 int Datos[10];
4 int Tope;
5 }
6 struct Pila P;
7 void Inicializa(), Push(int);
Andrade Palacios Luis Ulises Pilas

8 int PilaLlena(), Tope();

9 main(){
10 int I, Num;
11 Inicializa();
12 I = 0;
13 do{
14 printf(“Dame numero: “);
15 scanf (“%d”, &Num);
16 Push(Num);
17 I=I+1;
18 }while (I<5);
19 printf (“Elemento Tope: %d “, Tope())
20 }
21 void Inicializa ()
22 {
23 P.Tope = -1;
24 }
25 void Push (int elem)
26 {
27 if (PilaLlena() ¡= 1) {
28 P.Tope = P.Tope+1;
29 P.datos[P.Tope] = elem;
30 }
31 else{
32 printf (“Pila llena”);
33 }
34 }
35 int PilaLlena ()
36 {
37 if (P.Tope == 4)
38 return 1;
39 else
40 return 0;
41 }
42 int Tope()
43 {
44 return P.datos[P.Tope];
45 }
Andrade Palacios Luis Ulises Pilas

4. Mediante la estructura de datos de pila estática, guarda la información de

quince estudiantes cada uno con su cuenta, nombre y una calificación.
Presentarla a manera de tabla.

CODIGO:

1 struct Nodo{
2 int Cve;
3 char Des[30];
4 float Precio;
5 struct Nodo *ant, *sig;
6 };
7 struct Nodo *Inicio, *Final, *Nuevo;
8 void Inicializar(), DesplegarIF(), DesplegarFI();
9 main(){
10 do{
11 printf(“1. Insertar 2.Desplegar Inicio-Fin 3.
12 Desplegar Fin-Inicio 4. Salir”);
13 scanf(“%d”, &op);
14 switch(op){
15 case 1: Insertar();
16 case 2: DesplegarIF();
17 case 3: DesplegarFI();
18 }
19 }while(op;=4);
20 }
21 void Inicializar(){
22 Inicio = Final = NULL;
23 }
24 void Insertar(){
25 Nuevo=(struct Nodo *) malloc(sizeof(struct Nodo));
26 printf (“Clave: “) scanf (“%d”, Nuevo->Cve);
27 printf (“Descripcion:”) scanf (“%s”, Nuevo->Des) ;
28 printf (“Precio: ”) scanf (“%f”, Nuevo->Precio) ;
29 Nuevo->sig = Nulo;
30 Nuevo->ant = Final;
31 Final = Nuevo;
32 if (Inicio = Nulo) Inicio = Nuevo;
33 }
34 void DesplegarIF(){
35 struct Nodo *aux;
36 aux=Inicio;
37 while (aux ¡= NULL){
38 printf (“Clave: “, aux->Cve);
39 printf (“Descripcion: “,aux ->Des) ;
40 printf (“Precio: “,aux ->Precio) ;
Andrade Palacios Luis Ulises Pilas

41 aux = aux->sig;
42 }
43 }
44 void DesplegarFI(){
45 struct Nodo *aux;
46 aux=Final;
47 while (aux ¡= NULL){
48 printf (“Clave: ”, aux->Cve);
49 printf (“Descripcion: “,aux ->Des) ;
50 printf (“Precio: ”,aux ->Precio) ;
51 aux = aux->ant;
52 }
53 }
REFERENCIAS:
Oblancarte. (2014). Pila (Stack). Oscar Blancarte Software Architect. Recuperado
de: https://www.oscarblancarteblog.com/2014/08/06/estructura-de-datos-pila-
stack/

Gerry Studios. (2021). Estructuras de datos en C. Pila (Explicación +

implementación). [Video]. YouTube

Zohonero Martínez, I. y Joyanes Aguilar, L. (2008). Estructuras de datos en Java.

Madrid etc, Spain: McGraw-Hill España. Recuperado
de https://elibro.net/es/ereader/cesun/50117?page=292.