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ón Declaració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 == (MAX_PILA-1)) 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.elementos [++pila.cima] = elem;

}

int desapilar ()

{

int ele;

ele= pila.elementos [pila.cima];

pila.elementos [pila.cima]=0;

-- pila.cima;

return ele;

}

Procedimiento de desapilado

Pilas – codificación

Procedimiento de mostrar una pila.

void mostrar()

{

int ele,vec[5],c,i=-1;

while (vacia()!=1){

ele= desapilar();

i++;

vec[i]=ele;

printf(“\t %d\t”,ele);

}

for(c=i;c>=0;c--)apilar(vec[c]);

}

/* programa tipo de pila */

#include <stdio.h>

#include <conio.h>

void crear();

int vacia();

int llena();

void apilar (int elem);

int desapilar ();

void vostrar();

struct tpila {

int cima;

int elemento[5];

} pila;

int main ()

{

int elem, op,i;

crear();

printf("pila creada\n");

do{

printf ("1.Apilar\n 2. Desapilar\n 3. Salir\n");

scanf("%d",&op);

switch (op) {

case 1: printf ("Ingrese un numero");

scanf("%d",&elem);

apilar(elem);

break;

case 2: elem = desapilar();

printf("\n elemento desapilado %d",elem);

break;

case 3: break;

}

if (vacia()) printf ("\n pila vacia");

if (llena()) printf ("\n pila llena");

printf ("\n\n PILA....");

mostrar();

} while (op!=3);

}

Programa de ejemplo

Colas Una 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ón Declaración

struct tcola {

int elems;

int entrada, salida;

int elemento[max_cola];

} cola;

void crear()

{

cola.elems = 0;

cola.salida =cola.entrada = 0;

}

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) cola.entrada =0;

}

int desencolar ()

{

int ele;

if (vacia()!=1){ cola.elems--;

ele= cola.elemento [cola.salida];

cola.elemento[cola.salida]=0;

cola.salida++;

if (cola.salida == max_cola) cola.salida =0;}

else printf(“no hay elementos”);

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;

int main ()

{

int elem, op,i;

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);

encolar(elem);

break;

case 2: elem = desencolar();

printf("\n elemento desapilado %d",elem);

break;

case 3: break;

}

if (vacia()) printf ("\n cola vacia");

if (llena()) printf ("\n cola llena");

printf ("\n\nCOLA....\n");

mostrar();

} while (op!=3);

}

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ón Declaració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( )

{

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;

}

...

}

Listas - codificación Función para recorrer una lista y calcular la suma de sus elementos void recorrer()

{

int suma;

p = L;

while (p != NULL) {

printf("%d, ", p->clave);

suma = suma + p->clave;

p = p->sig;

}

printf("\nsuma:%d",suma);

}

Listas - codificación Funció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 actualizar la cabecera */ }

else { /* inserta entre medias o al final */ nuevo->sig = actual;

anterior->sig = nuevo;

}}

Listas - codificación Funció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ón Funció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( )

{

int i,suma;

L = NULL; /* Crea una lista vacía */

for (i = 4; i >= 1; i--)

{

/* Reserva memoria para un nodo */

p = (struct lista *) malloc(sizeof(struct lista));

p->clave = i; /* Introduce la información */

p->sig = L; /* reorganiza */

L = p; /* los enlaces p->L->NULL*/

}

recorrer( );

insertar(5);

recorrer();

borrar (2);

recorrer ();

}