Pilas. Una pila es un conjunto ordenado de elementos en la cual se pueden agregar y eliminar elementos en un extremo de ella.

Este extremo de la pila se conoce como tope.

long-mx

4 1 5
0

tope

Operaciones Las operaciones ms importantes reciben nombre espacial Agregar un elemento a la pila: push(P,x) Remover un elemento de una pila: pop(P) Sin embargo, son tiles otras operaciones como: tope(P), anula(P), vaca(P), Etc. Implementacin de Pilas #define long-mx 100 struc pila { int tope; int elemento[long-mx]; }; struct pila P;

Algunas consideraciones para la implementacin de operaciones ms comunes. 1.- Una pila puede crecer como mximo el tamao del arreglo. Es una limitacin importante. Se dice en este caso que la memoria disponible es esttica. 2.- Una pila est vaca si y slo si P.tope = -1 Si el arreglo comienza con 1, P.tope = 0 3.- La pila esta cargada a la izquierda (o el fondo) y se supone que entre un elemento y el siguiente no hay celdas vacas. Es decir la pila est compactada a la izquierda o al fondo. 1. anula (P), deja la pila P vaca (drsticamente), retorna la lista vaca. (criterio convencional) P.tope -1

T(n) = cte, cualquier-caso. anula(P) es O(1)

2. vaca(P), determina si la lista P est vaca. Retorna V o F segn el caso. if ( P.tope = -1) retorna V T(n) = cte, cualquier-caso. vaca(P) es O(1) 3. tope(P), retorna el elemento que est en el tope de la pila P. No saca el elemento, slo lo muestra. Tiene sentido si la pila no est vaca. return (P.elemento[P.tope]) T(n) = cte, culaquier caso tope(P) es O(1)

4.

push(P,x), agrega el elemento x a la pila P. Slo es posible si el tope de P es menor que long-mx P.tope++ P.elemento[P.tope] = x T(n) = cte, cualquier caso. push(P,x) es O(1)

5.

pop(P), saca el elemento que est en el tope de la pila. Si la pila est vaca no tiene sentido. P.tope - T(n) = cte, cualquier caso. pop(P,x) es O(1)

6. long(P), retorna el nmero de elementos que tiene la pila. En rigor esta

operacin requiere sacar uno a uno los elementos de P a medida que se van contando. Obliga tambin a reconstruir la pila P. struct pila Q; int contador = 0; while not Vaca(P) { contador ++; push(Q,tope(P)); pop(P) } T(n) = n para sacar los n elementos T(n) = 2n sacar y devolver los elementos long(P) es O(n)

7.

invierte(P), convierte la pila P en una pila en que los elementos de P aparecen en forma invertida

1 3 2
P
Requiere una pila Q de paso.

2 3 1
P invertida

T(n) = n, requiere sacar todos los elementos de la pila P

8.

busca(x,P), retorna V o F segn sea el caso. Si x est en la pila, retorna V si no retorna F. T(n) = n, peor-caso T(n) = cte, mejor-caso T(n) = (n 1)/2 caso promedio busca(x,P) es O(n)

9.

ordena(P)

4 1 3 2

4 3 2 1

//Ejemplo N 1: Editor de texto //Significado de smbolos: # cancela carcter anterior, //@ elimina lnea, return fin de lnea anula(P) while not retun { c=getchar(); if (c = #) pop(P); else if (c = @) anula(P); else push(c,P); } Imprimir P en orden inverso El resultado de: abc#d##e es ae

Ejemplo N 2: Equilibrio de Parntesis Considere la expresin matemtica que incluya varios conjuntos de parntesis anidados, por ejemplo: 7 ((x*((x+y) / (j-3)) + y ) / (4- 2.5)) Se quiere comprobar: 1.- Que existe la misma cantidad de parntesis derechos e izquierdos 2.- Cada parntesis derecho est precedido por un parntesis izquierdo Expresiones que violan la condicin 1 ((a+b) a + B( Expresiones que violan la condicin 2 )a+b(-c (a+b))-(c+d

Ejemplo N 3: Notacin pre, inter y postfija Consideremos dos nmeros a y b. Supongamos que se quiere aplicar el operador + a los operandos a y b. A la representacin a+b se le denomina interfija A la representacin +ab se le denomina prefija A la representacin ab+ se le denomina postfija Los prefijos pre, inter y post hacen referencia a la posicin relativa del operador. Para evaluar la expresin a + b * c se requiere saber cual de las operadores se ejecuta primero. Sabemos que la * tiene prioridad frente a la +. Los parntesis pueden indicar lo contrario. O sea a + b * c = a + (b * c) Convertir en postfija una expresin. Aplicando las reglas de precedencia, primero convertimos la parte de la expresin que se evala primero. Es decir, las operaciones con precedencia mayor se convierten primero.

Ejemplo: a+(b*c) a + (b c *) a(bc*)+ abc*+ Ejemplo: (a+b)*c (ab+)*c (ab+)c* ab+c*

expresin con parntesis, interfija convierte la multiplicacin convierte la suma representacin postfija expresin con parntesis, interfija convierte la suma convierte la multiplicacin representacin postfija

Las reglas para convertir de interfija a postfija son simples siempre y cuando se conozca el orden de precedencia. En general el orden de precedencia es el siguiente: exponenciacin multiplicacin / divisin ( de izquierda a derecha) suma / resta ( de izquierda a derecha)

Ejemplo a+b a+bc (a + b ) * ( c d ) a^b*cd+e/f /(g+h) (( a + b ) * c ( d e )) ^ ( f + g ) ab/(c*d^e) interfija ab+ ab+cab+cd-* ab^c*def/gh+/+ ab+ c*de--fg+^ abcde^*/postfija

+ab -+abc *+abcd +-*^abcd//ef+gh ^-*+abcde+fg a/b*c^de prefija

Cmo evaluar una expresin postfija? El algoritmo para evaluar debe considerar que cada operador en una cadena o expresin postfija hace referencia a los dos operandos anteriores de la cadena. Por supuesto, uno de estos operando puede ser el resultado de aplicar un operador anterior. Para la evaluacin es til una pila. Supongamos que cada vez que leemos un operando lo agregamos a la pila. Cuando llegamos a un operador, sus operandos sern los dos elementos superiores de la pila. Despus podemos remover estos dos elementos, ejecutar la operacin y agregar el resultado a la pila para que est disponible como operando del siguiente operador.

//Algoritmo que evala una expresin postfija //explora la expresin de entrada leyendo un elemento cada vez anula(P) while (no se el fin de la entrada) { simbolo = siguiente elemento de la entrada; if (simbolo es un operando) push(P, simbolo); else { operador2 = tope(P); pop(P); operador1 = tope(P); pop(P); valor = resultado de aplicar simbolo a los operadores; push(P,valor); } } return(tope(P));

Colas
Las colas son un tipo particular de listas. Una cola es una lista en la que los elementos pueden suprimirse por un extremo llamado parte anterior de la cola y pueden agregarse elementos por el otro extremo llamado parte posterior. Es una estructura del tipo FIFO, es decir el primero en entrar es el primero en salir Recordar que la pila es una estructura del tipo LIFO, es decir el ltimo en entrar es el primero en salir Las operaciones bsicas o primitivas son: inserta (x,q) inserta x en la parte posterior de la cola q suprime (q) suprime el elemento de la parte anterior de la cola q frente (q) retorna el elemento de la parte anterior de q vaca (q) V o F segn est o no vaca la cola. anula (q) Deja la cola vaca drsticamente

Implementacin de colas en arreglos. #define longmax 50 struct cola { int elem[longmax]; int ant, post; }; struct cola q; Tener cuidado con el desbordamiento. 0 q.elem

longmax -1

q.ant

q.post

Al principio se establece q.post = -1 y q.ant = 0 0 9

q.ant q.post
La cola esta vaca cada vez que q.post < q.ant. La cantidad de elementos en la cola en cualquier momento es dado por q.post q.ant + 1 Despus de insertar tres elementos y eliminar dos la situacin es la siguiente:

4
q.ant q.post

Si se insertan o agregan siete elementos la situacin sera la siguiente:

5
q.post

q.ant

Notar que el nmero de elementos = 9 2 + 1 La pregunta es se puede agregar ms elementos a la cola? A simple vista esto no es posible. Tambin se puede llegar al absurdo en donde la matriz o arreglo este casi vaco y no se puedan agregar ms elementos. Cmo solucionar este problema.? Una posibilidad es modificar el procedimiento suprime(q) para que cada vez que se suprima un elemento, toda la cola se corra al principio del arreglo. Para hacer este corrimiento se requiere una cola auxiliar. Si esto fuera as, la cola no necesitara tener el campo ant ( q.ant = 0, permanentemente). El costo sera considerable, T(n) = 2n.

Otra posibilidad es hacer que el espacio disponible se comporte como un crculo, una rueda sin fin. En este caso se puede utilizar la siguiente expresin para actualizar q.ant y q.post q.ant = (q.ant mod longmx) + 1 q.post = (q.post mod longmax) + 1 Sin embargo, el problema de diferenciar una cola vaca de una cola que no tiene espacio disponible para crecer, persiste.

Cola vaca 0 9

q.ant q.post Cola ocupando el espacio completo 0 9

q.ant q.post En ambos casos los valores para q.ant y q.post son iguales

Cola vaca 0 9

q.ant q.post Cola ocupando el espacio completo 0

4
q.post

q.ant

Cola vaca si q.ant = q.post Si en el siguiente paso q.ant = q.post, implica no hay espacio.