Estructura de Datos En C++ Dr. Romeo Sánchez Nigenda. E-mail: romeo.sanchez@gmail.com http://yalma.fime.uanl.mx/~romeo/ Oficina: 1er. Piso del CIDET. Oficina con Dr. Oscar Chacón Horas de Tutoría: 10am-11am Martes y Jueves, 3:30pm-4:30pm Miércoles, 2:00pm-4:00pm Viernes. Website: http://yalma.fime.uanl.mx/~romeo/ED/2011/ Sesiones: 48

Objetivo General: Conocerá y manejará las estructuras internas de información Temario: Conceptos Básicos La Pila Colas Recursión Listas Árboles Ordenamiento Búsqueda Administración de Almacenamiento Total a calificar: 110 puntos. 40% Tareas 30% Examen Parcial 30% Examen Final 10% Participación

Material de apoyo: Software: Estructura de Datos con C y C++. Yedidyah Langsam, Moshe J. Augenstein, Aaron M. Tenenbaum, Brooklyn College Segunda Edición, Prentice-Hall. Algorithms. Third Edition. Parts 1-4, Fundamentals Data Structures Sorting Searching Robert Sedgewick. Estructura de Datos. Román Martínez, Elda Quiroga. Thomson Learning. Cualquier libro de Estructura de Datos! Software: Compiladores GCC (GNU Compiler Collection) IDEs (Integrated Development Environment): http://www.eclipse.org/downloads/ http://kdevelop.org/ http://www.bloodshed.net/devcpp.html

2. La Pila (Stack) Objetivo: El alumno aprenderá el concepto de la estructura denominada la pila y manejará la inserción y eliminación de elementos en ella, así como sus aplicaciones Temario: Definición y ejemplos Representación de Pilas Operaciones con Pilas Aplicaciones

La Pila (Stack) Conjunto de elementos en el cual se puede agregar y eliminar elementos por un extremo, el cual es llamado el tope o parte superior (top) de la pila. Tope Tope F E D C B A G F E D C B A Agrega ‘G’ Último elemento insertado es el primero en suprimirse (estructura LIFO). El único acceso es el tope de la pila

La Pila: Operaciones Primitivas Agregar (push(i)): Agrega elemento i al tope de la pila Remover (pop()): Remueve elemento del tope de la pila, y se aplica a pilas no vacías. Stacktop : Retorna el elemento superior de la pila sin quitarlo (pop + push). StackEmpty: Retorna verdadero si la pila está vacía, falso en lo contrario C B A B A B A A A D Vacía = True Push(A) Push(B) Push(C) Pop() Pop() Push(D)

Ejemplo Para verificar que una expresión aritmética es correcta verificamos que: Sus paréntesis están balanceados, es decir que el número de paréntesis que abres es el mismo al número de paréntesis que cierras. ((5+8)*10)/(3+5-9): Cada paréntesis izquierdo abre un ámbito, y cada derecho lo cierra. La profundidad de anidamiento en un determinado punto es la cantidad de ámbitos abiertos. Debe ser 0 en una expresión balanceada. ( ( 5, +, 8 ( *, 10 / ( 3,+,5,-,9 Push(‘(’) Push(‘(’) Pop () Pop () Push(‘(’)

Representación de Pilas Una pila requiere básicamente de dos elementos: Una variable suficientemente grande para almacenar los elementos insertados en la pila (por ejemplo un arreglo). Un campo que registre la posición actual del tope de la pila Ejemplo: #define STACKSIZE 100 //Tamaño de la Pila struct pila{ int cima; int elementos[STACKSIZE]; } struct pila p;

Representación de Pilas La operación isStackEmpty int isStackEmpty(struct pila * P){ return (P->cima == -1); } La operación Pop int pop (struct pila * P){ if(isStackEmpty(P)){ cout<<“Error Pila Underflow”; exit(1): return (P->elementos[P->cima--]); La operación Push void push(struct pila * P, int elemento){ if(cima== STACKSIZE-1){ cout<<“Error Pila Overflow”; S->cima++; S->elementos[cima]=elemento; return Cima 5 7 5 7 Cima-- Cima++ 5 7 Cima 5 7

Representación de Pilas La operación stackTop Int stackTop(struct pila * P){ if(isStackEmpty(P)){ cout<<“Error Pila Vacía”; exit(1): } return P->elementos[P->cima];

Ejemplo: Evaluación de una expresión postfija. Los prefijos pre, post e inter hacen referencia a la posición relativa del operador (e.g., +,-,*,/,$) A + B : Interfija AB + : Postfija + AB : Prefija Cuando evaluamos una expresión aritmética, utilizamos las reglas de precedencia de los operadores, por ejemplo: Exponenciación ($), Multiplicación, División Adición y Sustracción Operadores de misma precedencia se utiliza la regla de izquierda a derecha, exceptuando la exponenciación que es de derecha a izquierda

Ejemplos: Evaluación a una expresión postfija. Siguiendo las reglas de precedencia A + (B * C) A + (B C *) A (B C *) + A B C * + (A + B) * C (A B +) * C (A B +) C * A B + C * A + B – C A B + - C A B + C - (A + B) * (C – D) (A B +) * (C – D) (A B +) * (C D -) (A B +) (C D -) * A B + C D - * A $ B * C – D + E / F / (G + H) A $ B * C – D + E / F / (G H +) A B $ C * … E F / G H + / A B $ C * D - E F / G H + / + A – B / (C * D $ E) A – B (C * D $ E) / A – B (C * D E $) / A – B (C D E $ *) / A B (C D E $ *) / - A B C D E $ * / -

Ejemplo: Algoritmo para evaluar una expresión Postfija Cada operador en una cadena postfija hace referencia a los dos operandos anteriores en la cadena Uno de los operandos puede ser el resultado de aplicar un operador anterior Mipila = 0 //Pila vacía Cadena = getCadena() //Obtén la cadena postfija de entrada Int index = 0 //Apunta al primer elemento de la cadena while((symb = cadena[index] )!= NULL){ //Symb representa el carácter que se checará if(symb es un operando) push(Mipila, symb) else{ //Symb es un operador operando2 = pop(Mipila) operando1 = pop(Mipila) value = resultado de aplicar symb a operando1 y operando2 push(Mipila, value) index++ } return pop(Mipila)