Estructuras PILA - COLA - LISTA

PILAS Operaciones APILAR DESAPILAR 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. 5 4 3 2 1 Operaciones APILAR DESAPILAR

Pilas - codificación Declaración struct tpila { int cima; int elementos[MAX_PILA]; } pila; Procedimiento de creación void crear( ) { pila.cima = -1; }

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; } Función que devuelve 1 si la pila esta llena int llena () { int r=0; if (pila.cima == (MAX_PILA-1)) r=1; return r; }

Pilas – codificación Procedimiento de apilado void apilar (int elem) { pila.elementos [++pila.cima] = elem; } Procedimiento de desapilado int desapilar () { int ele; ele= pila.elementos [pila.cima]; pila.elementos [pila.cima]=0; -- pila.cima; return ele; }

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 de ejemplo /* programa tipo de 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); case 3: break; } if (vacia()) printf ("\n pila vacia"); if (llena()) printf ("\n pila llena"); printf ("\n\n PILA...."); mostrar(); } while (op!=3); /* 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; 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 Se encola 3 números 3,1,4 1 2 3 4 5 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; Procedimiento de creación void crear() { cola.elems = 0; cola.salida =cola.entrada = 0; }

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; } Función que devuelve 1 si la cola esta llena int llena () { int r=0; if (cola.elems ==max_cola) r=1; return r; }

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; } Procedimiento de desencolar 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; }

Programa de ejemplo /* programa tipo de cola cricular */ 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); case 3: break; } if (vacia()) printf ("\n cola vacia"); if (llena()) printf ("\n cola llena"); printf ("\n\nCOLA....\n"); mostrar(); } while (op!=3); /* 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; Programa de ejemplo

Listas Operaciones INSERTAR RECORRER BORRAR 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 - codificación Declaración autoreferencial Declaración struct lista {   int clave;   struct lista *sig; } *L, *p,*actual, *anterior, *nuevo; Declaración autoreferencial Procedimiento de creación de lista vacía L = NULL;

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... 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; } 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; }

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

Programa de ejemplo int main( ) { #include <stdlib.h> 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 (); #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

F I N