Leccion 3.1.1 Ejemplos Algoritmos Pilas

Leccion 3.1.1 EJERCICIOS CON PILAS Una pila es una estructura lineal de datos con la característica especial de que ahora, no podemos hacer las inserciones y las eliminaciones en cualquier lugar, sino que obligatoriamente las tenemos que hacer por un extremo de la lista. Ese extremo lo llamamos cima de la pila. Esto supone que se procesen los elementos de la pila en orden inverso a su entrada en la estructura, es decir, el primer elemento de la pila que usare será el último que ha entrado (LIFO). Con una pila podemos hacer dos operaciones básicas, PUSH (meter) y POP (sacar). Aparte de estas dos funciones se pueden definir otras como la de pila vacía o top, que me dice cual es elemento que está en la cima de la pila pero sin sacarlo. Se puede implementar con memoria estática (arrays) o con memoria dinámica (listas enlazadas). Si utilizo un array, tendré que definir cual es el tamaño máximo del array, que será el de la pila, y aparte tendré definida una variable cima que tendrá en cada momento el índice que corresponde al elemento del array que está en la cima de la pila. Pila = array [1..max_pila] de Cima: entero Para señalar que la cima está vacía, cima es igual a 0 porque no tiene que apuntar a ningún elemento. Implementación de una pila con memoria estática: Algoritmo prin_pila Const Max_pila = Var P: array [1..max_pila] de C: entero Elem: Inicio C <- 0 Leer (elem) Si pila_vacia (C) = verdadero Entonces escribir “Pila vacia” Sino sacar (pila,c,elem) Escribir “Elemento sacado”elem Fin si Fin Funcion pila_vacia (cima: entero): booleano ESTRUCTURAS DE DATOS – LECCION 3.1.1 EJEMPLOS PILAS

Página 1

Trusted by over 1 million members

Try Scribd FREE for 30 days to access over 125 million titles without ads or interruptions! Start Free Trial Cancel Anytime.







Inicio Si cima = 0 Entonces retorno verdadero Sino retorno falso Fin si Fin Procedimiento meter (ent-sal pila: array[1..max_pila] de ; cima: entero; elem:) Inicio si cima = max_pila entonces escribir “Pila llena” sino cima <- cima + 1 pila[cima] <- elem fin si Fin Funcion cima_pila (pila: array[1..max_pila] de ; cima: entero): Inicio Retorno pila[cima] Fin Procedimiento sacar (ent-sal pila: array[1..max_pila] de ; cima: entero; ent-sal e: ) Inicio E <- cima_pila (cima,pila) Cima <- cima – 1 Fin

Implementación de una pila con memoria dinámica: Tipo nodo: registro Info: Sig: puntero a nodo Fin registro Algoritmo manejo_pila Var Cima: puntero a nodo Elem: Inicio Cima <- nil







Escribir “Elemento sacado”elem Fin si Fin Funcion pila_vacia (cima: puntero a nodo): booleano Inicio Si cima = nil Entonces retorno verdadero Sino retorno falso Fin si Fin Procedimiento poner (ent-sal cima: puntero a nodo; elem: ) Var Nuevo: puntero a nodo Inicio Si DISP = nil Entonces escribir “No hay memoria” Sino nuevo <- DISP DISP <- DISP ->sig Nuevo->info <- elem Nuevo->sig <- cima Cima <- nuevo Fin si Fin Funcion cima_pila (cima: puntero a nodo): Inicio Retorno cima info Fin Procedimiento sacar (ent-sal cima: puntero a nodo; ent-sal elem: ) Var Borrado: puntero a nodo Inicio Elem <- cima_pila (cima) Borrado <- cima Cima <- cima->sig Borrado->sig <- DISP DISP <- borrado Fin







En lo que se refiere a la resolución de problemas, muchas veces para plantear el problema imaginamos objetos y acciones que se relacionan entre si. Por ejemplo, un mesero tiene platos de colores apilados; de vez en cuando el que lava los platos coloca un plato recién lavado sobre la pila de platos; y en otras ocaciones el mesero toma el plato que esta hasta arriba y sirve ahí la comida que ha sido preparada por el cocinero para posteriormente llevarla a su destino. Si sabemos de qué color es la pila inicial de platos, y en qué momentos el que lava los platos colocó platos sobre la pila(y claro, tambien sabemos el color de estos), y en qué momentos el mesero retiró el plato que se encontraba hasta arriba; podemos saber de qué color será el plato que le toca a cada cliente. Una manera de saberlo podría ser, hacer una representación dramatica de los hechos; pero esto no es necesario, ya que tambien podríamos tomar un lapiz y un papel, y escribir una lista de los colores de los platos, posteriormente, ir escribiendo los colores de los platos que se pusieron en la pila al final de la lista, y borrar el ultimo color de la lista cada que un plato se retire. No se necesita ser un gran matemático para pensar en hacer eso, sin embargo, en el momento de querer implementar un programa en C que lo reprodusca, nos encontramos con que no tenemos ninguna lista donde se coloquen y se quiten cosas del final, tenemos solamente arreglos, variables, estructuras, apuntadores, etc. Claro que podemos simular esta lista con las herramientas que nos proporciona C, asi pues, los objetos( como como la pila de platos) ligados a operaciones (como (como poner un nuevo plato o quitar un plato) que modifican al objeto son llamados estructuras de datos. Una definición sencilla de estructura de datos: unión de un conjunto de datos y funciones que modifican dicho conjunto. Es muy importante conocer las estructuras de datos mas comunes que se utilizan en la programación, ya que la estructura de datos es vital para plantear el problema y al resolverlo, poder implementar su solución eficazmente.

Pilas Una pila, es la estructura de datos mencionada en el ejemplo anterior, es decir, un altero de objetos. O mas formalmente, una estructura de datos en la cual solo se pueden hacer 2 operaciones: colocar un elemento al final, o quitar un elemento del final. Lo unico que se puede hacer en una pila es colocar un objeto hasta arriba, o quitar el objeto que esta arriba, ya que si se quita un objeto de abajo o del centro(lo mismo que si se intenta







Imaginemos que el restaurant tiene en total 10 platos(un restaurant bastante pobre), ello nos indicaría que un arreglo de tamaño 10 podría guardar todos los platos sin temor a que el tamaño del arreglo no alcance. Suponiendo que inicialmente hay 2 platos, uno de color 1, y otro de color 2, el arreglo debería lucir algo asi: 2100000000 Si repentinamente el que lava los platos pone un plato hasta arriba de color 2, luego de ello el arreglo debería de lucir asi: 2120000000 Si luego pone hasta arriba un plato de color 3, entonces el arreglo debería de quedar asi: 2123000000 Pero si el mesero toma un plato de arriba, el arreglo estará de nuevo de esta manera: 2120000000 Si el mesero vuelve a tomar un plato de arriba, el arreglo quedará de esta manera: 2100000000 Para lograr esto, basta con declarar un arreglo y una variable. Tal que el arreglo diga especificamente qué platos hay en la pila, y la variable cuántos platos hay. Entonces, podemos declarar una pila de la siguiente manera(suponiendo que la pila es de números enteros): int pila[ tamaño maximo ]; ]; int p=0; Cada que queramos añadir un elemento en la parte superior de la pila, es suficiente con esta línea de código: pila[p++]=objeto ; Y cuando queramos retirar el elemento que este en la parte superior.







Asi mismo, si la pila sobrepasa su tamaño máximo, el error devuelto es “stack overflow” o “desbordamiento de pila”(ahora ya sabemos qué quieren decir algunos errores comunes que saturan el monitor en pantallas azules). Problema 1. Comprueba que es suficiente utilizar p-- en lugar de pila[p]= 0 para retirar un elemento de la pila. Problema 2. En el álgebra, comunmente se utilizan signos de agrupación tales como ( ), [ ] o { }, y se pueden utilizar para indicar el orden en que se realizarán las operaciones aritmeticas. Ej. “[a(x+y)+c]d+(b(c+d))”, sin embargo, existen ciertas formas invalidas de utilizar dichos signos de agrupación Ej. “[a+b)” ó “(a” ó “(b))” o tambien “([a+b)c]”. Es decir, cada signo que “abre” debe tener un signo correspondiente que lo “cierre”, cada signo que “cierra” debe de tener un signo correspondiente qué cerrar, y los signos no se pueden traslapar. Escribe un programa, que dada una expresión algebrarica, determine si tiene o no error en los signos de agrupación en tiempo lineal. Problema 3. Una manera de encriptar mensajes(no muy segura), es colocar parentesis de manera arbitraria, y todo lo que esta dentro de un parentesis, ponerlo al reves, por ejemplo “Olimpiada de Informatica” se puede encriptar como “Olimpia(ad) de I(rofn)matica”, los parentesis tambien se pueden anidar, es decir, otra forma de encriptar el mismo mensaje podría ser “Olimpia(am(nfor)I ed (da))tica”. Escribe un programa, que dado un mensaje encriptado, determine el mensaje original en tiempo lineal. (9°Olimpiada Mexicana de Informática) Problema 4. Hay n faros acomodados en línea recta, cada faro puede tener una altura arbitraria, y además, cada faro brilla con cierta intensidad. La luz de cada faro ilumina unicamente a los primeros faros en cada dirección cuyas alturas sean estrictamente mayores a la del faro que emite la luz. La iluminación total de un faro, es la suma de las luces que llegan al faro(sin incluir la propia). Escribe un programa, que dadas las alturas de los n faros y las intensidades de cada uno, determine cual es el faro mas iluminado en tiempo lineal. (USACO 2006) Problema 5. Una cuadricula bicolorada, es aquella en la cual cada cuadro puede estar pintado de color negro o de color blanco(todos los cuadros estan pintados de alguno de estos 2 colores). Puedes asumir que cada casilla de la cuadricula tiene area 1. Escribe un programa, que dada una cuadricula bicolorada, determine el área del mayor rectangulo (dentro de la cuadricula) pintado de un solo color. Tu programa deberá funcionar en tiempo lineal (lineal en función del número de casillas de la cuadricula, NO en función de la base o de la altura). (Croatian Olympiad in Informatics) Problema 6. Considera el siguiente algoritmo recursivo para generar permutaciones de arreglo [ ] desde inicio hasta fin :









4 fin_de_funcion; 5 para i=inicio hasta fin 6 intercambia(arreglo[inicio], arreglo[i]); 7 pemuta(arreglo[ ], inicio+1, fin); 8 intercambia(arreglo[inicio], arreglo[i]); 9 fin_de_funcion; Escribe una función no recursiva que genere todas las permutaciones de arreglo [ ] desde inicio hasta fin , con la misma complejidad que la función que se muestra

Ejemplo del Uso de Pilas en la solución de problemas relacionados con la computación Procesamiento de las llamadas a subrutinas y sus retornos •

Tenemos un procedimiento principal y tres rutinas

•

Los retornos se deben hacer en orden inverso a las llamadas







Operaciones con las Pilas •

ADD (item, stack)  stack Inserta item en stack, y devuelve el stack modificado

•

DELETE (stack)  stack Elimina el elemento del tope de stack, y devuelve el stack modificado

•

TOP (stack)  item Devuelve el ítem ubicado en el tope de stack. No modifica stack







const N = 1000 var top: integer var s: array [1..N] of integer procedure ADD (item) begin if top ≥ N then call STACK_FULL else top := top + 1 s [top] := item end if end procedure DELETE () begin if top ≤ 0 then call STACK_EMPTY else top := top – 1 end if end procedure TOP () begin if TOP = 0 then return (error) else







begin { inicialización } top := 0 end

Si queremos usar esta definición: var p: snack begin p.ADD (1) p.ADD (2) p.ADD (3) p.DELETE() print (p.TOP()) end Ejemplo en C++ /*PILA.C Programa de Pilas. El programa realiza lo siguiente: Introducir datos a la pila Sacar datos de la pila Imprimir. La pila es una subclase de lista lineal en la que las inserciones y eliminaciones se realizan por un solo extremo y solamente el ultimo elemento resulta accesible. Esta estructura se conoce como LIFO last-in,first-out (ultimo en entrar, primero en salir). En una pila las inserciones y las supresiones se efectuan en la misma punta de la pila llama Tope de pila. Programa compilado con Turbo C version 2.01







void Aplicacion(void); boolean EstaVacia(struct Pila *); void ImprimePila(struct Pila *); int main(void) { char valor; int opcion; struct Pila *PtrPila; PtrPila=NULL; Menu(); scanf("%d",&opcion); while(opcion!=salir){ switch(opcion){ case push:printf("Introduce una letra a la pila: "); scanf("\n%c",&valor); Push(&PtrPila,valor); ImprimePila(PtrPila); getch(); break; case pop: if(!EstaVacia(PtrPila)) printf("El valor sacado de la pila es: %c.\n",Pop(&PtrPila)); ImprimePila(PtrPila); getch(); break; default: gotoxy(30,20); printf("Opcion incorrecta."); getch(); Menu(); break; } Menu(); scanf("%d",&opcion); } gotoxy(30,24); printf("Fin de %s",__FILE__); sleep(1); return 0; }









void Push(struct Pila **Tope,char valor) { struct Pila *Nuevo; Nuevo=(struct Pila *)malloc(sizeof(struct Pila)); if(Nuevo!=NULL){ Nuevo->Dato=valor; Nuevo->Siguiente= *Tope; *Tope=Nuevo; } else printf("%c no insertado. No hay memoria suficiente.\n",valor); } char Pop(struct Pila **Tope) { struct Pila *Temporal; char ValorPop; Temporal= *Tope; ValorPop=(*Tope)->Dato; *Tope=(*Tope)->Siguiente; free(Temporal); return ValorPop; } void ImprimePila(struct Pila *Actual) { if(Actual==NULL){ printf("La pila esta vacia.\n"); }

Leccion 3.1.1 Ejemplos Algoritmos Pilas

Recommend Documents