Estructura de Datos En C++
Dr. Romeo Sánchez Nigenda.
E-mail: [email protected]
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:
1.
2.
3.
4.
5.
6.
7.
8.
9.
Conceptos Básicos
La Pila
40% Tareas
Colas
30% Examen Parcial
Recursión
30% Examen Final
Listas
10% Participación
Árboles
Ordenamiento
Búsqueda
Administración de Almacenamiento
Total a calificar: 110 puntos.
Material de apoyo:
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
F
G
E
F
D
Agrega ‘G’
Tope
E
C
D
B
C
A
B
A

Ú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
Vacía = True
B
B
B
A
A
A
A
A
D
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.
(
(
(
Push(‘(’)
Push(‘(’)
5, +, 8
(
Pop ()
*, 10
/
Pop ()
(
Push(‘(’)
3,+,5,-,9
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--]);
}

Cima
return
5
7
5
Cima--
7
La operación Push
void push(struct pila * P, int elemento){
if(cima== STACKSIZE-1){
cout<<“Error Pila Overflow”;
exit(1):
}
S->cima++;
S->elementos[cima]=elemento;
}
Cima++
Cima
5
5
7
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 *) +
ABC*+
(A + B) * C
(A B +) * C
(A B +) C *
AB+C*
A+B–C
AB+-C
 AB+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)
}
Descargar

La Pila