Carátula para entrega de prácticas

Facultad de Ingeniería Laboratorios de docencia

Laboratorio de Computación
Salas A y B

Profesor: Sáenz García Elba Karen

Asignatura: Estructura de Datos Y Algoritmos 1

Grupo: 4

No de Práctica(s): 5

Integrante(s): Dionicio Juárez Agustín

Reyes Castillo Christian

Palacios Cacique Esteffany Abigail

No. de Equipo de
cómputo empleado:

Semestre: 2 semestre

Fecha de entrega: 20 de agosto 2018

Observaciones:
 CALIFICACIÓN: ________________

Introducción:

Listas:
Es una colección de elementos dispuestos uno detrás del otro, en la que cada elemento se conecta al
siguiente por un “Enlace” o “Puntero”.

Los nodos de las listas al igual que las colas y pilas, está compuesta por una parte de información (que pude
ser datos enteros, flotantes, caracteres, estructuras..) y el puntero que mantiene el enlace entre un nodo y
otro.

Una cola es un tipo especial de lista abierta en la que sólo se puede insertar nodos en uno de los extremos de
la lista y sólo se pueden eliminar nodos en el otro. Además, como sucede con las pilas, las escrituras de datos
siempre son inserciones de nodos, y las lecturas siempre eliminan el nodo leído.
Este tipo de lista es conocido como lista FIFO (First In First Out), el primero en entrar es el primero en salir.
El símil cotidiano es una cola para comprar, por ejemplo, las entradas del cine. Los nuevos compradores sólo
pueden colocarse al final de la cola, y sólo el primero de la cola puede comprar la entrada.

La pila es una estructura de datos que permite almacenar datos en el orden LIFO (Last In First Out, en
español, "último en entrar, primero en salir").
La recuperación de los datos es realizada en el orden inverso de su inserción.

Para la implementación he elegido una lista enlazada simple, presentada sobre la vertical.
Ya que la inserción es siempre hecha al inicio de la lista, el primer elemento de la lista será el ultimo elemento
ingresado, por lo tanto estará en la cabeza de la pila.
No he utilizado un puntero fin, como lo hice en el caso de la lista enlazada simple, ya que el objetivo no es el
de tratar una lista enlazada, sino una pila.
Lo interesante es que el último elemento ingresado, será el primer elemento recuperado.
Objetivo:

Utilizar las definiciones, características, procedimientos y ejemplos de las estructuras lineales Pila y Cola, con
la finalidad de comprenderlas e implementarlas

Desarrollo:

Actividad 1

Implementar con la guía del profesor un programa donde se muestren las operaciones que se pueden realizar
sobre una pila representada por un arreglo unidimensional.

Código:

#include<stdio.h>

#include<stdlib.h>

#define max 5

struct tipoPila

int tope;

int *stack;

};

typedef struct tipoPila tpila;

/*prototipos de funciones*/

void creaPila(tpila *s);

void liberaPila(tpila *s);

int llena(tpila *s);

int vacia (tpila *s);

void push(tpila *s,int dato);

int pop(tpila *s);

void mostrar(tpila s);

int v,d,p,x;

int main()

tpila pila1;

creaPila(&pila1);

do

printf("\tMenu\n");

printf("\n1.Push\n");

printf("2.-Pop\n");

printf("3.-Liberar\n");

printf("4.-Mostrar\n");

printf("5.-Salir\n");

printf("Elige una opción\n");

scanf("%d",&p);

switch(p)

case 1:

printf("Dame tu dato a introducir\n");

scanf("%d",&d);

push(&pila1,d);

break;

case 2 :

v=pop(&pila1);

printf("el dato extraido es:%d",v);

break;

case 3:
 liberaPila(&pila1);

break;

case 4:

mostrar(pila1);

break;

case 5:

printf("Adios\n");

break;

default:

printf("Error, no es una opcion.\n");

printf("\nDesea ejecutar de nuevo el programa si=1 y no=2\n");

scanf("%d",&x);

}while(x==1);

printf("\nGracias por este semestre");

return (0);

void creaPila(tpila *s)

s->tope=0;

s->stack=(int*)malloc(max*sizeof(int));

void liberaPila(tpila *s)

free (s->stack);

int llena(tpila *s)

 {

if (s->tope==max)

return (0);

else

return (1);

int vacia(tpila *s)

if (s->tope==0)

return(0);

else

return (1);

void push (tpila *s,int dato)

if (!llena (s))

printf ("la pila esta llena");

else

s->stack[s->tope]=dato;

s->tope++;

int pop(tpila *s)

if(!vacia (s))

printf("pila vacia" );
return -1;

else

s->tope--;

return s->stack[s->tope];

void mostrar(tpila s)

int i;

printf("\t\tLOS DATOS QUE CONTIENE TU PILA SON:\n");

for (i=0;i<s.tope;i++)

printf("%d\n",s.stack[i]);

Actividad 1.1 Con el programa anterior, modificarlo para introducir datos en una pila, sacarlos e irlos
introduciendo en otra pila, mostrar lo que tiene la segunda pila.
Código:

#include<stdio.h>

#include<stdlib.h>

#define max 5

struct tipoPila

int tope;

int *stack;

};

typedef struct tipoPila tpila;

/*prototipos de funciones*/

void creaPila(tpila *s);

void liberaPila(tpila *s);

int llena(tpila *s);

int vacia (tpila *s);

void push(tpila *s,int dato);

int pop(tpila *s);

void mostrar(tpila s);

int v,d,p,x,e;

int main()

tpila pila1;

creaPila(&pila1);

tpila pila2;

creaPila(&pila2);

printf("Este programa guarda los datos extraidos de una pila en otra\n" );

do
{

printf("\tMenu\n");

printf("\n1.Push\n");

printf("2.-Pop 1\n");

printf("3.-Liberar 1\n");

printf("4.-Mostrar pila 2\n");

printf("5.-Liberar 1\n");

printf("6.-Pop 2\n");

printf("7.-Salir\n");

printf("Elige una opción\n");

scanf("%d",&p);

switch(p)

case 1:

printf("Dame tu dato a introducir\n");

scanf("%d",&d);

push(&pila1,d);

break;

case 2 :

v=pop(&pila1);

printf("el dato extraido es:%d",v);

push(&pila2,v);

break;

case 3:

liberaPila(&pila1);

break;

case 4:

mostrar(pila2);
 break;

case 5:

liberaPila(&pila2);

break;

case 6:

e=pop(&pila2);

printf("el dato extraido es:%d",e);

case 7:

printf("Adios\n");

break;

default:

printf("Error, no es una opcion.\n");

printf("\nDesea ejecutar de nuevo el programa si=1 y no=2\n");

scanf("%d",&x);

}while(x==1);

printf("\nGracias por este semestre");

return (0);

void creaPila(tpila *s)

s->tope=0;

s->stack=(int*)malloc(max*sizeof(int));

void liberaPila(tpila *s)

free (s->stack);
 }

int llena(tpila *s)

if (s->tope==max)

return (0);

else

return (1);

int vacia(tpila *s)

if (s->tope==0)

return(0);

else

return (1);

void push (tpila *s,int dato)

if (!llena (s))

printf ("la pila esta llena");

else

s->stack[s->tope]=dato;

s->tope++;

int pop(tpila *s)

if(!vacia (s))
 {

printf("pila vacia" );

return -1;

else

s->tope--;

return s->stack[s->tope];

void mostrar(tpila s)

int i;

printf("\t\tLOS DATOS QUE CONTIENE TU PILA SON:\n");

for (i=0;i<s.tope;i++)

printf("%d\n",s.stack[i]);

}
Actividad 2

Realizar un programa que muestre si una palabra es un paliándome, utilizar pilas.

Código:

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#define _Nodoc_H_

struct Nodo{

char Dato;

struct Nodo* Sig;

};

struct Nodo* inicNodoD(char Dato){

struct Nodo*init;

init = (struct Nodo*) malloc (sizeof(struct Nodo));

init->Dato = Dato;

init->Sig = NULL;

return init;

};

struct Nodo* inicNodoDN(char Dato, struct Nodo* Sig){

struct Nodo* init;

init = (struct Nodo*) malloc (sizeof(struct Nodo));

init->Dato=Dato;

init->Sig=Sig;

return init;

};

struct Pila{

struct Nodo* H;

struct Nodo* T;
 int size;

};

struct Pila* initPila(){

struct Pila*init;

init =(struct Pila*) malloc (sizeof(struct Pila));

init->H=NULL;

init->T=NULL;

init->size=0;

return init;

};

void imprimirPila(struct Pila *p){

struct Nodo * aux =p->H;

while(aux!=NULL){

printf(" %c ", aux->Dato);

aux=aux->Sig;

};

};

void push(struct Pila* p, char Dato){

struct Nodo *aux;

aux = inicNodoDN(Dato,p->H);

p->H=aux;

p->size++;

if(p->size==1)

p->T=aux;

};

char pop(struct Pila*p){

if(p->size==0){

printf("\n\t La pila no tiene elementos \n");

 return ' ';

char aux=p->H->Dato;

struct Nodo* borrame=p->H;

p->H=p->H->Sig;

borrame->Sig=NULL;

if(p->size==1)

p->T=NULL;

free(borrame);

p->size--;

return aux;

};

void main(){

struct Pila* act;

act=initPila();

struct Nodo* itp;

struct Nodo* itc;

char* ingr;

ingr=(char*)malloc(256*sizeof(char));

unsigned int i=0, aux;

printf("\n\t Palindromos \n Este programa verifica si tu cadena es un palindromo\n");

printf(" Ingresa una cadena \n");

gets(ingr);

printf("\n Tu cadena sera diferente si no cuidas las mayusculas \n");

aux=strlen(ingr);

while(i<=aux){

if(*(ingr+i)==' '){

i++;
 }

else{

push(act, *(ingr+i));

i++;

};

imprimirPila(act);

itp=act->H;

i=i;

while(i<=aux){

if((itp->Dato)==(itc->Dato)){

itp=itp->Sig;

itc=itc->Sig;

i++;

printf(".");

else{

printf("\n Tu cadena no es un palindromo\n");

exit(0);

};

printf("\n Tu cadena, es un palindromo\n");

while(act->size!=0){

pop(act);

};

free(act);
 free(ingr);

Actividad 3

Implementar un programa donde se muestren las operaciones que se pueden realizar sobre una cola
representada con un arreglo unidimensional.

Código:

#include<stdio.h>

#include<stdlib.h>

#define max 5

struct tipoCola

int inicio;

int fin;

int *q;
 };

typedef struct tipoCola tCola;

/*prototipos de funciones*/

void creaCola(tCola *qq);

void libera(tCola *qq);

int llena(tCola *qq);

int vacia (tCola *qq);

void incerta(tCola *qq,int dato);

int remover(tCola *qq);

void mostrar(tCola q);

int v,d,p,x;

int main()

tCola cola1;

creaCola(&cola1);

do

printf("\tMenu\n");

printf("\n1.Incerta\n");

printf("2.-Remover\n");

printf("3.-Liberar\n");

printf("4.-Mostrar\n");

printf("5.-Salir\n");

printf("Elige una opción\n");

scanf("%d",&p);

switch(p)

case 1:
 printf("Dame tu dato a introducir\n");

scanf("%d",&d);

incerta(&cola1,d);

break;

case 2 :

v=remover(&cola1);

printf("el dato extraido es:%d",v);

break;

case 3:

libera(&cola1);

break;

case 4:

mostrar(cola1);

break;

case 5:

printf("Adios\n");

break;

default:

printf("Error, no es una opcion.\n");

printf("\nDesea ejecutar de nuevo el programa si=1 y no=2\n");

scanf("%d",&x);

}while(x==1);

printf("\nGracias por usar el programa ");

return (0);

void creaCola(tCola *qq)

 {

qq->inicio=0;

qq->fin=0;

qq->q=(int*)malloc(max*sizeof(int));

void libera(tCola *qq)

free (qq->q);

int llena(tCola *qq)

if (qq->fin==max)

return (0);

else

return (1);

int vacia(tCola *qq)

if (qq->inicio==0&& qq->fin==0)

return(0);

else

return (1);

void incerta(tCola *qq,int dato)

if (!llena (qq))

printf ("la pila esta llena");

else
 {

qq->q[qq->fin]=dato;

qq->fin++;

int remover(tCola *qq)

int x,i;

if(!vacia (qq))

printf("vacia" );

return -1;

else

x=qq->q[qq->inicio];

for(i=0;i<qq->fin;i++)

qq->q[i]=qq->q[i+1];

qq->fin--;

return x;

void mostrar(tCola qq)

int i;

printf("\t\tLOS DATOS QUE CONTIENE TU PILA SON:\n");

for (i=0;i<qq.fin;i++)
 {

printf("%d\n",qq.q[i]);

Conclusiones:

Reyes Castillo Christian:

Al realizar esta práctica por primera vez utilizamos pilas, ya que a través de las clases entendimos como se
hace una pila y una cola, las cuales son de mucha utilidad para usar la memoria en tiempo de ejecución,
además de hacer programas como un palíndromo donde tuvimos que aplicar los conocimientos de cómo es
una pila utilizando en la pila el push, pop, liberar, mostrar, además de que en los otros programas todo esto lo
metimos en un menú para ejemplificarlo mejor y que se viera más elegante, todos estos elementos de la pila,
también lo hicimos con las colas con insertar, remover, liberar ,etc e igual en un menú, una buena práctica,
muy tediosa y un poco complicada porque era muy larga.
Dionicio Juárez Agustín:

Utilizamos las pilas para implementar nuestros códigos, fue muy difícil hacerlo debido a que todavía no se
tiene muy bien el concepto de pilas, esto se debe a que las colas están diseñadas para devolver elementos
ordenados tal como llegan. Para esto, las colas poseen un punto de acceso y otra de salida que lógicamente
están en extremos opuestos. Siempre se ve un elemento que esta primero o al frente, entonces al
implementar eso en los códigos, se tuvo muchos problemas que al final se logró solucionar

Palacios Cacique Esteffany Abigail:Durante esta práctica entendimos como funciona una pila o una cola,
las cuales son de gran utilidad para guardar datos y removerlos con facilidad