Estructuras PILAS, LISTAS Y COLAS -...
21
Estructuras PILA - COLA - LISTA
Transcript of Estructuras PILAS, LISTAS Y COLAS -...
Estructuras
PILA - COLA - LISTA
Una pila es una estructura de datos de acceso restrictivo a sus elementos. Es una estructura de tipo LIFO (Last In First Out), es decir, último en entrar, primero en salir.
Operaciones APILAR
DESAPILAR
5
4
3
2
1
PILAS
Pilas - codificaciónDeclaración
struct tpila {
int cima;
int elementos[MAX_PILA];
} pila;
void crear( )
{
pila.cima = -1;
}
Procedimiento de creación
Pilas - codificación
Función que devuelve 1 si la pila esta vacía
int vacia()
{
int r=0;
if (pila.cima ==-1) r=1;
return r;
}
int llena ()
{
int r=0;
if (pila.cima ==5) r=1;
return r;
}
Función que devuelve 1 si la pila esta llena
Pilas – codificación
Procedimiento de apilado
void apilar (int elem)
{
pila.elemento [++pila.cima] = elem;
return;
}
int desapilar ()
{
int ele;
ele= pila.elemento [pila.cima];
pila.elemento [pila.cima]=0;
-- pila.cima;
return ele;
}
Procedimiento de desapilado
/* programa tipo de pila */
#include <stdio.h>
#include <conio.h>
void crear();
int vacia();
int llena();
void mostrar();
void apilar (int elem);
int desapilar ();
struct tpila {
int cima;
int elemento[5];
} pila;
void main ()
{
int elem, op,i;
clrscr();
crear();
printf("pila creada\n");
do {
printf ("\n\n1.Apilar\n 2. Desapilar\n 3. Salir\n");
scanf("%d",&op);
switch (op) {
case 1: printf ("Ingrese un numero");
scanf("%d",&elem);
if(llena()!=1) {
apilar(elem);
}
else printf("\nLa pila esta llena, imposible
apilar mas elementos.\n");
break;
case 2: if(vacia()!=1){
elem = desapilar();
printf("\n elemento desapilado %d",elem);
}
else printf("\nLa pila esta vacia, imposible desapilar
elementos\n");
break;
case 3: break;
}
mostrar();
}while (op!=3);
getch();
return;
}
Programa de ejemplo
Pilas – Función Mostrar
Procedimiento de mostrar dentro de un ciclo.void mostrar()
{
int ele, vec[5],i=-1,c;
printf("\nPila:\n");
do
{
ele= pila.elemento [pila.cima];
pila.elemento [pila.cima]=0;
-- pila.cima;
printf("- %d -",ele);
i++;
vec[i]= ele;
}while(vacia()!=1);
for(c=i;c>=0;c--)
{
apilar(vec[c]);
}
return;
ColasUna cola es una estructura de datos de acceso restrictivo a sus elementos
Es una estructra de tipo FIFO (First In First Out), es decir: primero en entrar, primero
en salir.
Operaciones ENCOLAR
DESENCOLAR
1
2
3
4
5
Se encola 3 números 3,1,4
Se desencola un número (3)
Se encola un número (7)
Colas - codificaciónDeclaración
struct tcola {
int elems;
int entrada, salida;
int elemento[max_cola];
} cola;
void crear()
{
cola.elems = 0;
cola.salida =cola.entrada = -1;
}
Procedimiento de creación
Colas - codificación
Función que devuelve 1 si la cola esta vacía
int vacia()
{
int r=0;
if (cola.elems ==0) r=1;
return r;
}
int llena ()
{
int r=0;
if (cola.elems ==max_cola) r=1;
return r;
}
Función que devuelve 1 si la cola esta llena
Colas – codificación
Procedimiento de encolar
void encolar (int elem)
{
cola.elems++;
cola.elemento[++cola.entrada] = elem;
if (cola.entrada ==(max_cola-1)) cola.entrada =-1;
return;
}
int desencolar ()
{
int ele;
cola.elems--;
ele= cola.elemento [cola.salida];
cola.elemento[cola.salida]=0;
cola.salida++;
if (cola.salida ==(max_cola)) cola.salida =0;
return ele;
}
Procedimiento de desencolar
/* programa tipo de cola cricular */
#include <stdio.h>
#include <conio.h>
void crear();
int vacia();
int llena();
void encolar (int elem);
int desencolar ();
# define max_cola 5
struct tcola {
int elems;
int entrada, salida;
int elemento[max_cola];
} cola;
void main ()
{
int elem, op,i;
clrscr();
crear();
printf("cola creada\n");
do{
printf ("1.Encolar\n 2. Desencolar \n 3. Salir\n");
scanf("%d",&op);
switch (op) {
case 1: printf ("Ingrese un numero");
scanf("%d",&elem);
if (llena()!=1) encolar(elem);
else printf(“\nCola llena\n”);
break;
case 2: if (vacia()!=1) {elem = desencolar();
printf("\n elemento desapilado %d",elem);}
else printf(“\n Cola vacia\n”);
break;
case 3: break;
}
printf ("\n\nCOLA....\n");
for (i=0;i<max_cola;i++){
printf ("elemento [%d] = %d\n",i,cola.elemento[i]);
}
} while (op!=3);
getch();
return;
}
Programa de ejemplo
Una lista es una estructura de datos secuencial. Una manera de clasificarlas es por la forma de acceder al siguiente elemento:-lista densa: la propia estructura determina cuál es el siguiente elemento de la lista. Ejemplo: un array.- lista enlazada: la posición del siguiente elemento de la estructura la determina el elemento actual. Es necesario almacenar al menos la posición de memoria del primer elemento. Además es dinámica, es decir, su tamaño cambia durante la ejecución del programa.
Operaciones INSERTAR
RECORRER
BORRAR
Listas
Listas - codificaciónDeclaración
struct lista
{
int clave;
struct lista *sig;
} *L, *p,*actual, *anterior, *nuevo;
L = NULL;
Procedimiento de creación de lista vacía
Declaración autoreferencial
Listas - codificación
Procedimiento para insertar información al comienzo
int main(void)
{
clrscr();
int i,suma;
L = NULL; /* Crea una lista vacia */
for (i = 4; i >= 1; i--)
{
/* Reserva memoria para un nodo */
p = (struct lista *) malloc(sizeof(struct lista));
scanf(“%d”,&p->clave); /* Introduce la informacion */
p->sig = L; /* reorganiza */
L = p;
getch();
}
...
Listas - codificaciónFunción para recorrer una lista y calcular la suma de sus elementosvoid recorrer()
{
int suma;
p = L;
while (p != NULL) {
printf("%d, ", p->clave);
suma = suma + p->clave;
p = p->sig;
}
printf("\nsuma:%d",suma);
getch();
return;
}
Listas - codificaciónFunción para insertar un elemento al final o en medio de la lista ordenada.
void insertar(int elem)
{
/* 1.- se busca su posicion */
anterior = actual = L;
while (actual != NULL && actual->clave < elem) {
anterior = actual;
actual = actual->sig;
}
/* 2.- se crea el nodo */
nuevo = (struct lista *) malloc(sizeof(struct lista));
nuevo->clave = elem;
/* 3.- Se enlaza */
if (anterior == NULL || anterior == actual) { /* inserta al principio */
nuevo->sig = anterior;
L = nuevo; /*importante: al insertar al principio actulizar la cabecera */
}
else { /* inserta entre medias o al final */
nuevo->sig = actual;
anterior->sig = nuevo;
}}
Listas - codificaciónFunción para insertar un elemento. Otra forma de codificar...
void Insertar( int v) {
/* Crear un nodo nuevo */
nuevo = (struct lista *)malloc(sizeof(struct
lista));
Nuevo->clave = v;
/* Si la lista está vacía */
if(L==NULL || L->clave > v) {
/* Añadimos la lista a continuación del nuevo
nodo */
nuevo->siguiente = L;
/* Ahora, el comienzo de nuestra lista es en
nuevo nodo */
L = nuevo;
}
else {
/* Buscar el nodo de valor menor a v
*/
anterior = L;
/* Avanzamos hasta el último
elemento o hasta que el siguiente tenga
un valor mayor que v */
while(anterior->siguiente !=NULL
&& anterior->siguiente->valor <= v)
anterior = anterior->siguiente;
/* Insertamos el nuevo nodo después
del nodo anterior */
nuevo->siguiente = anterior-
>siguiente;
anterior->siguiente = nuevo;
}
}
Listas - codificaciónFunción para borrar un elemento de la lista.void borrar( int elem)
{
/* 1.- busca su posición. Es casi igual que en la inserción, ojo al (<) */
anterior = actual = L;
while (actual != NULL && actual->clave < elem) {
anterior = actual;
actual = actual->sig;
}
/* 2.- Lo borra si existe */
if (actual != NULL && actual->clave == elem) {
if (anterior == actual) /* borrar el primero */
L = actual->sig;
else /* borrar en otro sitio */
anterior->sig = actual->sig;
free(actual);
}}
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
void recorrer( );
void insertar(int elem);
void borrar( int elem);
struct lista
{
int clave;
struct lista *sig;
}*L, *p,*actual, *anterior, *nuevo;
Programa de ejemplo
int main(void)
{
clrscr();
int i,suma;
L = NULL; /* Crea una lista vacia */
for (i = 4; i >= 1; i--)
{
/* Reserva memoria para un nodo */
p = (struct lista *) malloc(sizeof(struct lista));
p->clave = i; /* Introduce la informacion */
p->sig = L; /* reorganiza */
L = p; /* los enlaces p->L->NULL*/
getch();
}
recorrer( );
insertar(5);
recorrer();
borrar (2);
recorrer ();
return 0;
}
