Apuntes para el curso de
“Estructuras de datos en C/C++ ”
Dr. Abdiel E. C´ aceres Gonz´ alez
ITESM-CCM
2 de junio de 2005
Resumen
Una estructura de datos es una manera de almacenar y organizar datos para facilitar el acceso y modificaciones. No hay una estructura de datos que sirva para todos los prop´ ositos, y por eso es importante saber sus ventajas y desventajas. Este documen- to es una colecci´ on de apuntes para el curso de Estructuras de Datos. Los apuntes se han tomado de algunas fuentes que son detalladas en la secci´ on de bibliograf´ıa.
´ Indice
1. Preliminares de programaci´ on en C/C++ 3
1.1. Arreglos 3
1.2. Apuntadores 10
1.3. Estructuras C/C++ 15
1.4. Ejercicios de programaci´ on 19
2. La pila 21
2.1. Definici´ on y ejemplos 21
2.2. Operaciones b´ asicas 24
2.3. Ejemplo: N´ umero de par´ entesis 25
2.4. La estructura de datos Pila en C/C++ 26
2.5. La representaci´ on en C/C++ de las operaciones de una pila 27
2.6. Problemas de programaci´ on 29
3. Colas 31
3.1. Estructura de las colas en C/C++ 32
3.2. Colas con prioridad 33
3.3. Ejercicio de programaci´ on 34
4. Recursi´ on 36
4.1. Peligros en la recursividad 39
4.2. Ejercicios de programaci´ on 40
5. Listas 42
5.1. Grafos 42
5.2. Listas simplemente encadenadas 44
5.3. El uso de memoria din´ amica en C/C++ 51
5.4. Listas ligadas usando memoria din´ amica 54
5.5. Ejercicios de programaci´ on 56
6. Arboles ´ 57
6.1. Concepto general de ´ arbol 57
6.2. ´ Arboles binarios 57
6.3. Representaci´ on en C/C++ de los ´ arboles binarios 64
6.4. ´ Arboles 66
6.5. Ejercicios de programaci´ on 69
7. Grafos 71
7.1. Recordatorio de las definiciones 71
7.2. Aplicaci´ on ejemplo 73
1. Preliminares de programaci´ on en C/C++
En esta secci´ on recordaremos tres temas de programaci´ on en C/C++ que son fundamentales para estudiar estructuras de datos; estos temas son los arreg- los, los registros y los punteros. Los tres temas han sido tomados fundamen- talmente de [MP97]
1.1. Arreglos
Definici´ on 1 Un arreglo se compone de elementos de igual tama˜ no almace- nados linealmente en posiciones de memoria consecutiva.
Se puede acceder a cada elemento de datos individual utilizando un sub´ındice, o ´ındice, para seleccionar uno de los elementos. En C/C++ , un arreglo no es un tipo de datos est´ andar; es un tipo agregado compuesto de cualquier otro tipo de datos.
Los arreglos se pueden definir usando tipos de datos mixtos debido a que se supone que todos los elementos son del mismo tama˜ no. Puesto que todos los elementos son del mismo tama˜ no y ya que este hecho se utiliza para ayudar a determinar c´ omo localizar un elemento dado, resulta que los elementos son almacenados en localidades de memoria contiguas.
Lo m´ as importante a tener en cuenta es: El nombre de un arreglo es visto por el compilador como un puntero-constante al primer elemento del arreglo. Esto es muy importante: a) El nombre del arreglo es visto como un tipo puntero, y m´ as espec´ıficamente, b) un puntero constante -significa una direcci´ on de memoria bloqueada para el primer elemento de un arreglo-. Por ejemplo, aunque una declaraci´ on de arreglo toma la f´ orma gen´ erica:
Tipo_ElementoArray NombreArray [ NumeroDeElementos ] El compilador ve la declaraci´ on como
Tipo_ElementoArray * const NombreArray = &NombreArray[0];
Por esta raz´ on, un identificador de arreglo no puede ser usado nunca como un valor-i (valor izquierdo). Los valores izquierdos representan variables que su contenido puede ser alterado por el programa; frecuentemente aparecen a la izquierda de las sentencias de asignaci´ on.
Si los nombres de arreglo fueran variables izquierdos permitidos, el programa
podr´ıa cambiar sus contenidos.
float SalariosDeEmpleados[Max_empleados];
. . .
SalariosDeEmpleados = 45739.0;
El efecto har´ıa cambiar la direcci´ on inicial del propio arreglo.
1.1.1. Declaraciones de un arreglo La sintaxis de declaraci´ on de arreglos es:
tipo nombre_arreglo [numero_de_elementos];
Los siguientes son dos ejemplos de declaraciones de arreglos v´ alidas en C/C++
:
int CoordenadasDePantalla[5]; /*Un arreglo de 5 enteros */
char IDCompania[20]; /*Un arreglo de 20 caracteres */
Figura 1. Arreglo CoordenadasDePantalla con ´ındices de desplazamiento v´ alido En la figura 1 se muestra el primer arreglo que fue declarado con el tipo de n´ umeros enteros, llamado CoordenadasDePantalla, ocupa en memoria 5 localidades de memoria contiguas, cada una de ellas capaz de almacenar un n´ umero entero. Actualmente es com´ un que los n´ umeros enteros sean de 32 bits, esto hace que el arreglo CoordenadasDePantalla ocupe 32 × 5 = 160 bits
No se permite utilizar nombres de variables dentro de los corchetes. Por esto no es posible evitar la especificaci´ on del tama˜ no del arreglo hasta la ejecuci´ on del programa. La expresi´ on debe ser un valor constante, para que el compilador sepa exactamente cu´ anto espacio de memoria tiene que reservar para el arreglo.
Una buena pr´ actica de programaci´ on es usar constantes predefinidas.
#define Coordenadas_Max 20
#define Tamano_MaX_Compania_Id 15
int CoordenadasDePantalla[Coordenadas_Max];
char IDCompania[Tamano_MaX_Compania_Id];
El uso de constantes predefinidas garantiza que futuras referencias al arreglo no excedan el tama˜ no del arreglo definido.
1.1.2. Iniciaci´ on del arreglo
C/C++ proporciona 3 maneras de iniciar elementos del arreglo:
Por defecto: Cuando son creados, se aplica solamente a arreglos globales y est´ aticos.
Expl´ıcita: Cuando son creados, suministrando datos de iniciaci´ on
Tiempo de ejecuci´ on: Durante la ejecuci´ on del programa cuando se asig- nan o copias datos en el arreglo.
1.1.3. Acceso a los elementos de un arreglo
Si se tiene un error cuando se utilizan arreglos en C/C++ , de seguro el error involucra el acceso a los elementos del arreglo, por la simple raz´ on de que el primer elemento est´ a en una posici´ on 0, no 1. De manera que el ´ ultimo elemento del arreglo lo encontramos en n-1, donde n es el n´ umero de elementos.
Supongamos la siguiente declaraci´ on:
int Estado[Rango_Maximo_Estado]={-1,0,1};
La siguiente sentencia tiene acceso a -1:
Estado[0];
Si escribimos Estado[3] causar´ a un error porque no hay 4 elementos.
1.1.4. C´ alculo del tama˜ no de un arreglo (sizeof())
Es frecuente utilizar el operador sizeof() para calcular la cantidad de espacio que se necesita almacenar para un objeto:
/*
* exploresz.cpp
*/
#include<iostream.h>
#define maxDiasSemana 7 int main(void){
int desplazamiento, maxHorasDiarias[maxDiasSemana];
cout<<"sizeof(int) es"<<(int)sizeof(int)<<"\n\n";
for(desplazamiento=0;desplazamiento<maxDiasSemana;
desplazamiento++)
cout<<"&maxHorasDiarias["
<<desplazamiento
<<"]="
<<&maxHorasDiarias[desplazamiento]<<"\n";
return 0;
}
1.1.5. Arreglos multidimensionales
El t´ ermino dimensi´ on representa el n´ umero de ´ındices utilizados para referirse a un elemento particular en el arreglo. Los arreglos de m´ as de una dimensi´ on se llaman arreglos multidimensionales.
/*
/ dosDim.cpp
*/
#include <iostream>
#define numFilas 4
#define numColumnas 5
int main (int argc, char * const argv[]) {
int despFila, despColumna, desplazamiento, multiplo, despCalculados[numFilas][numColumnas];
for(despFila=0;despFila<numFilas;despFila++)
for(despColumna=0;despColumna<numColumnas;despColumna++){
desplazamiento=numColumnas-despColumna;
multiplo=despFila;
despCalculados[despFila][despColumna]=
(despFila+1)*despColumna+desplazamiento * multiplo;
};
for(despFila=0;despFila<numFilas;despFila++){
std::cout<<"Fila actual: "<<despFila<<"\n";
std::cout<<"Distancia relativa desde la base: "<<"\n";
for(despColumna=0;despColumna<numColumnas;despColumna++) std::cout<<" "
<<despCalculados[despFila][despColumna]
<<" ";
std::cout<<"\n\n";
}
return 0;
} }
El programa utiliza dos ciclos for para calcular e inicial cada uno de los elementos del arraglo a su respectiva distancia relativa desde la base. El arreglo creado tiene 4 filas y 5 columnas por fila, haciendo un total de 20 elementos enteros.
Los arreglos multidimensionales son almacenados de forma lineal en la memo- ria de la computadora. Los elementos en los arreglos multidimensionales est´ an agrupados desde el ´ındice m´ as a la derecha hacia el centro. En el ejemplo an- terior, fila 1, columna 1 ser´ıa el elemento 3 del arreglo almacenado. Aunque el c´ alculo del desplazamiento aparece un poco dif´ıcil, es referenciado f´ acilmente cada elemento del arreglo.
La salida del programa anterior es:
Fila actual: 0
Distancia relativa desde la base:
0 1 2 3 4
Fila actual: 1
Distancia relativa desde la base:
5 6 7 8 9
Fila actual: 2
Distancia relativa desde la base:
10 11 12 13 14
Fila actual: 3
Distancia relativa desde la base:
15 16 17 18 19
dosdim has exited with status 0.
1.1.6. Arreglos como argumentos de funciones
Es necesario recordar tres cosas al pasar arreglos como par´ ametros de fun- ciones:
1. Todos los arreglos son pasados en llamada-por referencia.
2. Debido a que el arreglo es pasado en llamada por referencia, ser´ıa in- correcto para la funci´ on llamada devolver el arreglo en una sentencia return();. Esta sentencia est´ a de m´ as.
3. Todos los elementos del arreglo son pasados a las funciones en llamada por valor. lo que significa que se pasa una copia del elemento, no la direcci´ on del elemento.
/*
// ereArray.xcode
*/
#include <iostream>
#include <ctype.h>
#define maxArray 5
void ArrayMayuscula(char Array[maxArray]);
int main (int argc, char * const argv[]) { int desplazamiento;
char Array[maxArray]=
{’a’,’e’,’i’,’o’,’u’};
for(desplazamiento=0;desplazamiento<maxArray;
desplazamiento++)
std::cout<<Array[desplazamiento];
std::cout<<"\n";
ArrayMayuscula(Array);
for(desplazamiento=0;desplazamiento<maxArray;
desplazamiento++)
std::cout<<Array[desplazamiento];
return 0;
}
void ArrayMayuscula(char Array[maxArray]) {
for(int desplazamiento=0;desplazamiento<maxArray;
desplazamiento++)
Array[desplazamiento]=toupper(Array[desplazamiento]);
//Aqui return array seria incorrecto
}
La salida del programa demuestra que el arreglo se pasa en llamada por refer- encia, ya que el primer ciclo for da como salida los contenidos de min´ usculas originales: aeiou, mientras que el segundo ciclo for en main() da como salida los contenidos del arreglo despu´ es del llamado a la funci´ on ArrayMayuscula():
AEIOU.
Claramente, dentro del cuerpo de la funci´ on ArrayMayuscula(), ha cambiado el arreglo de regreso en la funci´ on main(). el siguiente ejemplo es una simple modificaci´ on de este algoritmo, s´ olo que en vez de pasar el arreglo completo, se pasa cada elemento individual:
/*
// ereArray2.xcode
*/
#include <iostream>
#include <ctype.h>
#define maxArray 5
void ElementosArrayMayuscula(char unChar);
int main (int argc, char * const argv[]) { int desplazamiento;
char Array[maxArray]=
{’a’,’e’,’i’,’o’,’u’};
for(desplazamiento=0;desplazamiento<maxArray;desplazamiento++) std::cout<<Array[desplazamiento];
std::cout<<"\n";
for(desplazamiento=0;desplazamiento<maxArray;desplazamiento++) ElementosArrayMayuscula(Array[desplazamiento]);
for(desplazamiento=0;desplazamiento<maxArray;desplazamiento++) std::cout<<Array[desplazamiento];
return 0;
}
void ElementosArrayMayuscula(char unChar) {
unChar=toupper(unChar);
}
La salida del programa es:
aeiou aeiou
valarray has exited with status 0.
1.2. Apuntadores
Definici´ on 2 Un apuntador es una variable que contiene una direcci´ on de memoria.
Supongamos una variable de tipo entero que se llama contenidoRAM y otra variable que se llama direccionRAM que puede contener una variable de tipo entero. En C/C++ una variable precedida del operador & devuelve la direcci´ on de la variable en lugar de su contenido. As´ı que para asignar la direcci´ on de una variable a otra variable del tipo que contiene direcciones se usan sentencias como esta:
direccionRam = &contenidoRAM
Figura 2. contenidoRAM se asigna a la localidad de memoria con direcci´ on 7751 En la figura 2 se ilustra el nombre de la variable contenidoRAM y se observa que se encuentra en la direcci´ on 7751 de la memoria. El contenido de esta localidad no se muestra. Una variable que contiene una direcci´ on, tal como direccionRAM, se llama variable apuntador o simplemente apuntador.
Despues que la sentencia anterior se ejecuta, la direcci´ on de contenidoRAM ser´ a asignada a la variable apuntador direccionRAM. La relaci´ on se expresa diciendo que direccionRAM apunta a contenidoRAM. La figura 3 ilustra esta relaci´ on.
El accceso al contenido de una celda cuya direcci´ on est´ a almacenada en la
variable direccionRAM es tan sencillo como poner al inicio de la variable
apuntador un asterisco: *direccionRAM. Lo que se ha hecho es eliminar la
referencia directa. Por ejemplo, si se ejecutan las siguientes dos sentencias, el
valor de la celda llamada contenidoRAM ser´ a de 20 (v´ ease la figura 4).
Figura 3. Notaci´ on de flecha para los apuntadores direccionRAM = &contenidoRAM;
*direccionRAM = 20;
Figura 4. A contenidoRAM se le asigna el valor entero 20
1.2.1. Declaraciones de variables apuntador
C/C++ requiere una definici´ on para cada variable. Para definir una variable apuntador direccionRAM que pueda contener la direcci´ on de una variable int, se escribe:
int *direccionRAM;
Realmente existen dos partes separadas en esta declaraci´ on. El tipo de dato de direccionRAM es:
int *
y el identificador para la variable es direccionRAM
El asterisco que sigue a int significa “apuntador a”. Esto es, el siguiente tipo de dato es una variable apuntador que puede contener una direcci´ on a un int:
int *
En C/C++ una variable apuntador contiene la direcci´ on de un tipo de dato particular:
char *direccion_char;
char *direccion_int;
El tipo de dato de direccion char es diferente del tipo de dato de la variable apuntador direccion int. En un programa que define un apuntador a un tipo de dato y utliza ´ este para apuntar a otro tipo de dato, pueden ocurrir errores en tiempo de ejecuci´ on y advertencias en tiempo de compilaci´ on. Una pr´ actica de programaci´ on pobre ser´ıa definir un apuntador de una forma y luego utilizar ´ este de alguna otra forma. Por ejemplo:
int *direccion_int;
float un_float = 98.34;
direccion_int = &un_float;
1.2.2. Utilizaci´ on de punteros en sentencias sencillas Veamos el siguiente ejemplo:
/*
// changeVals.xcode
*/
(01) #include <iostream>
(02)
(03) int main (int argc, char * const argv[]) { (04) int A_int=15, B_int=37, Temp_int;
(05) int *direccion_int;
(06)
(07) std::cout<<"El contenido de A_int es:"<<A_int<<"\n";
(08) std::cout<<"El contenido de B_int es:"<<B_int<<"\n";
(09) direccion_int = &A_int;
(10) Temp_int = *direccion_int;
(11) *direccion_int = B_int;
(12) B_int = Temp_int;
(13) std::cout<<"Despues del intercambio:"<<"\n\n";
(14)
(15) std::cout<<"El contenido de A_int es:"<<A_int<<"\n";
(16) std::cout<<"El contenido de B_int es:"<<B_int<<"\n";
(17) return 0;
(18) }
En la l´ınea (04) se han declarado tres variables de tipo entero, se da a cada celda un nombre y se inicializan 2 de ´ estas. Supondremos que la direcci´ on de memoria asignada para la variable A int es la direcci´ on 5328, y la direcci´ on en memoria RAM asignada para la variable B int es la direcci´ on 7916, y la celda llamada Temp int se le ha asignado la direcci´ on 2385. V´ ease la figura 5;
Figura 5. Descripci´ on de las tres variables en la memoria
En la l´ınea (05) se define un apuntador a un tipo de dato entero llamado direccion int. La sentencia asigna la celda y da a ´ esta un nombre.
Luego, en la l´ınea (09), la tercera sentencia asigna a direccion_int la direc- ci´ on de A_int (figura 6).
Figura 6. direccion int dada la direcci´ on de A int
La l´ınea (10) utiliza la expresi´ on *direccion_int para acceder al contenido de la celda a la cual apunta direccion_int:
Temp_int = *direccion_int;
Por consiguiente, el valor entero 15 se almacena en la variable Temp_int. Si
no se pone el * enfrente de direccion_int;, la sentencia de asignaci´ on al-
macenar´ıa ilegalmente el contenido de direccion_int en la celda nombrada
Temp_int, pero se supone que Temp_int contiene un entero, no una direcci´ on.
Este puede ser un error muy dif´ıcil de localizar puesto que muchos compi- ladores no emiten ninguna advertencia/error.
Para empeorar el asunto, la mayor´ıa de los apuntadores son cercanos, lo que significa que ocupan 2 bytes (4 bytes para aplicaciones de 32-bits), el mismo tama˜ no que un entero en una PC.
La sentencia (11) copia el contenido de la variable B int en la celda apuntada por la direcci´ on almacenada en direccion int(figura 7):
*direccion_int = B_int;
Figura 7. Se copia el contenido de B int usando la notaci´ on de flecha de apuntadores La ´ ultima sentencia en la l´ınea (12) simplemente copia el contenido de una variable entera, Temp int en otra variable entera B int (figura 8
Figura 8. Se copia Temp int en B int utilizando asignaci´ on normal.
Debemos de asegurarnos de comprender la diferencia entre qu´ e se referencia cuando una variable puntero est´ a precedida por el operador de indirecci´ on y cu´ ando no est´ a precedida por este operador.
Para este ejemplo, la primera sintaxis es un apuntador a una celda que puede
contener un valor entero. La segunda sintaxis referencia la celda que contiene
la direcci´ on de otra celda que puede contener un entero.
1.2.3. Utilizaci´ on incorrecta del operador de direcci´ on
No se puede utilizar el operador de direcci´ on sobre toda expresi´ on C/C++ . El siguiente ejemplo demuestra aquellas situaciones donde no se puede aplicar el operador de direcci´ on &.
puedeAlmacenarDireccionDeConstante = &37;
int RAM_int = 5;
puedeAlmacenarDireccionDeExpresionTemp = &(RAM_int +15);
puedeAlmacenarDireccionDeRegistro = &varRegistro;
La primera sentencia trata de obtener ilegalmente la direcci´ on de un valor constante integrado. La sentencia no tiene sentido puesto que 37 no tiene una celda de memoria asociada con ´ este.
La segunda sentencia de asignaci´ on intenta devolver la direcci´ on de la expre- si´ on RAM_int+15. No existe direcci´ on asociada con la expresi´ on puesto que la expresi´ on en s´ı misma es realmente un proceso de manipulaci´ on de pila.
Normalmente, el ´ ultimo ejemplo respeta la demanda del programador para definir varRegistro como un registro m´ as que como una celda de almace- namiento en la memoria interna. Por consiguiente, no podr´ıa devolverse y almacenarse la direcci´ on de celda de memoria. El compilador C/C++ da la memoria de variable, no el almacenamiento de registro.
1.3. Estructuras C/C++
Definici´ on 3 Una estructura es un grupo de variables las cuales pueden ser de diferentes tipos sostenidas o mantenidas juntas en una sola unidad. La unidad es la estructura.
1.3.1. Sintaxis y reglas para estructuras en C/C++
En C/C++ se forma una estructura utilizando la palabra reservada struct, seguida por un campo etiqueta opcional, y luego una lista de miembros dentro de la estructura. La etiqueta opcional se utiliza para crear otras variables del tipo particular de la estructura:
struct campo_etiqueta{
tipo_miembro miembro_1;
tipo_miembro miembro_2;
tipo_miembro miembro_3;
: :
tipo_miembro miembro_n;
};
Un punto y coma finaliza la definici´ on de una estructura puesto que ´ esta es realmente una sentencia C/C++ . Algunos de los ejemplos usan la estructura:
struct stbarco{
char sztipo[iString15+iNull_char];
char szmodelo[iString15+iNull_char];
char sztitular[iString20+iNull_char];
int ianio;
long int lhoras_motor;
float fprecioventa;
};
En un programa, podemos asociar una variable con una estructura utilizando una sentencia similar a la siguiente:
struct stbarco stbarco_usado;
La sentencia define stbarco_usado de tipo struct stbarco. La declaraci´ on requiere el uso del campo etiqueta de la estructura. Si esta sentencia est´ a con- tenida dentro de una funci´ on, entonces la estructura, llamada stbarco_usado, tiene un ´ ambito local a esa funci´ on. Si la sentencia est´ a contenida fuera de todas las funciones de programa, la estructura tendr´ a un ´ ambito global. Es posible declarar una variable usando esta sintaxis:
struct stbarco{
char sztipo[iString15+iNull_char];
char szmodelo[iString15+iNull_char];
char sztitular[iString20+iNull_char];
int ianio;
long int lhoras_motor;
float fprecioventa;
} stbarco_usado;
Aqu´ı la declaraci´ on de variable va antes del punto y coma final. Cuando se asocia s´ olo una variable con el tipo estructura, el campo etiqueta puede ser eliminado, por lo que ser´ıa posible escribir:
struct {
char sztipo[iString15+iNull_char];
char szmodelo[iString15+iNull_char];
char sztitular[iString20+iNull_char];
int ianio;
long int lhoras_motor;
float fprecioventa;
} stbarco_usado;
1.3.2. Utilizaci´ on de miembros de estructuras
Para accesar a los miembros de las estructuras se usa el punto u operador miembro (.). La sintaxis es:
estructuraNombre.miembroNombre Por ejemplo en:
gets(stbarco_usado.szmodelo);
Aqu´ı, stbarco_usado es el nombre asociado con la estructura, y szmodelo es una variable miembro de la estructura, otro ejemplo:
std::cin>> stbarco_usado.sztipo;
Esta sentencia leer´ a la marca del stbarco_usado en el arreglo de caracteres, mientras la pr´ oxima sentencia imprimir´ a el precio de venta de stbarco_usado en la pantalla.
srd::cout<< stbarco_usado.fprecioventa;
Ejemplo de estructuras:
/* fractionStruct.cpp -
Programa para demostrar el uso de los tipos Struct en C++, este tipo de datos es util para los programadores para crear sus propias estructuras de tipos.
*/
#include <iostream>
using namespace std;
// Definimos un nuevo tipo de estructura llamada Fraction // como la definicion se puso antes del "main"
// los tipos Fraction se pueden usar como prototipos
struct Fraction {
// declaramos sus dos miembros int numerator;
int denominator;
}; // Note el punto y coma al final // funciones prototipos
void getFraction(Fraction &f);
void printFraction(const Fraction &f);
int main (int argc, char * const argv[]) {
// declaramos variables de tipo Fraction Fraction f1, f2;
// obtenemos dos fracciones y las desplegamos getFraction(f1);
cout << "\nf1 = ";
printFraction(f1);
getFraction(f2);
cout << "\nf2 = ";
printFraction(f2);
cout << endl;
return 0;
}
// pedimos al usuario los valores del denominador y numerador
// los almacenamos en su adecuado lugar en la estrcututra; checamos si // el valor del denominador es valido y lo ponemos en 1 si no lo es.
void getFraction(Fraction &f) { cout << "\nEnter the numerator: ";
cin >> f.numerator;
cout << "Enter the denominator: ";
cin >> f.denominator;
if (f.denominator == 0) {
cout << "\nIllegal denominator! Denominator is being set to 1.\n";
f.denominator = 1;
} }
// imprimimos la fraccion
void printFraction(const Fraction &f) {
cout << f.numerator << "/"
<< f.denominator << "\n";
}
Nota sobre las funciones prototipos:
Las funciones prototipo tienen los siguientes usos importantes:
Establecen el tipo devuelto para las funciones que devuelven otros tipos diferentes que int. Aunque las funciones que devuelven valores enteris no necesitan prototipos, se recomienda tener prototipos.
Sin prototipos completos, se hacen las conversiones est´ andares, pero no se checan los tipos o los n´ umeros de argumentos con el n´ umero de par´ ametros.
Los prototipos se usan para inicializar apuntadores a funciones, antes de que las funciones sean definidas.
La lista de par´ ametros se usa para checar la correspondencia de los argu- mentos en la llamada a la funci´ on con los par´ ametros en la definici´ on de la funci´ on
const en parmetros de funciones
El especificador const puede ser utilizado en la definici´ on de par´ ametros de funciones. Esto resulta de especial utilidad en tres casos. En los tres el fin que se persigue es el mismo: indicar que la funci´ on no podr´ a cambiar dichos argumentos:
Con par´ ametros de funciones que sean de tipo matriz (que se pasan por referencia). Ejemplo: int strlen(const char[]);
Cuando los par´ ametros son punteros (a fin de que desde dentro de la funci´ on no puedan ser modificados los objetos referenciados). Ejemplo: int printf (const char *format, ...);
Cuando el argumento de la funci´ on sea una referencia, previniendo as´ı que la funci´ on pueda modificar el valor referenciado. Ejemplo: int dimen(const X &x2);
1.4. Ejercicios de programaci´ on
1. El siguiente algoritmo es el m´ etodo de inserci´ on para ordenar elementos en un arreglo:
insertionSort(A) for j:=2 to length[A]
do key:=A[j]
-> Inserta el elemento A[j]
-> en la secuencia ordenada A[1..j-1]
i:=j-1
while i>0 and A[i]>key do A[i+1]=A[i]
i:=i-1 A[i+1]:=key
a) desarrolle un programa en C/C++ del m´ etodo de inserci´ on
b) ilustre c´ omo opera el algoritmo insertionSort(A) usando como en- trada el arreglo A=<31,41,59,26,41,58>
2. Reescriba el programa y n´ ombrelo insertionSortNondec para que or- dene los elementos en orden decreciente
3. Considere el siguiente problema de b´ usqueda:
Input: Una secuencia de n n´ umeros A = ha
1, a
2, . . . , a
ni y un valor v.
Output: Un ´ındice i tal que v = A[i] o el valor espacial N IL si v no ocurre en A.
Escriba un programa que resuelva este problema de b´ usqueda.
4. Considere el problema de sumar dos n´ umeros binarios de longitud n.
Cada n´ umero se almacena en uno de los arreglos A y B de tama˜ no n. La
suma se almacena en un arreglo C de tama˜ no n + 1, tambi´ en como un
n´ umero binario. Escriba un programa que resuelva este problema.
2. La pila
Uno de los conceptos m´ as ´ utiles en las ciencias de la computaci´ on es el de pila.
En esta secci´ on vamos a definir este concepto de manera abstracta y veremos c´ omo se usa para convertirse en una herramienta concreta y de gran valor en las soluciones de problemas. La informaci´ on contenida en esta secci´ on se ha tomado de [TA83].
2.1. Definici´ on y ejemplos
Definici´ on 4 Una pila (stack) es una colecci´ on ordenada de elementos en la cual se pueden insertar nuevos elementos por un extremo y se pueden retirar otros por el mismo extremo; ese estremos se llama “la parte superior” de la pila.
Si tenemos un par de elementos en la pila, uno de ellos debe estar en la parte superior de la pila, que se considera “el m´ as alto” en la pila que el otro. En la figura 9 el elemento F es el m´ as alto de todos los elementos que est´ an en la pila. El elemento D es el m´ as alto de los elementos A,B,C, pero es menor que los elementos E y F.
Figura 9. Pila con 6 elementos
Para describir c´ omo funciona esta estructura, debemos agregar un nuevo ele- mento, el elemento G. Despu´ es de haber agregado el elemento G a la pila, la nueva configuraci´ on es la que se muestra en la figura 10.
De acuerdo con la definici´ on, existe solamente un lugar en donde cualquier
elemento puede ser agregado a la pila. Despu´ es de haber insertado el nuevo
elemento, G ahora es el elemento en la cima. Debedos aclarar en qu´ e pila
deseamos insertar elementos, puesto que es posible tener m´ as de una pila al
mismo tiempo.
Figura 10. Operaci´ on de insertar el elemento G en la pila P
Cuando se desea retirar un elemento de la pila, solo basta ordenar que sea retirado un elemento; no podemos decir “retira C de la pila”, porque C no est´ a en la cima de la pila y solamente podemos retirar el elemento que est´ a en la cima. Para que la sentencia “retira C de la pila” tenga sentido, debemos replantear las ´ ordenes a algo como:
Retira de la pila hasta que el elemento retirado sea C.
Ni siquiera es necesario decir: “Retira un elemento de la pila...” porque es sobreentendido que solamente se puede sacar un elemento a la vez.
Siguiendo nuestro ejemplo, ahora deseamos retirar de la pila P. La configu- raci´ on global de la pila es como se muestra en la figura 11
Figura 11. Operaci´ on de retirar de la pila P
El concepto de pila es muy importante en computaci´ on y en especial en teor´ıa de lenguajes de programaci´ on. En lenguajes procedurales como Pascal o C, la pila es una estructura indispensable, debido a las llamadas a funci´ on.
Resulta que el flujo de instrucciones va de arriba hacia abajo, y cuando ocurre
una llamada a alguna funci´ on, el estado global del sistema se almacena en un
registro y ´ este en una pila. As´ı que la pila va a contenr todas las llamadas a
procedimientos que se hagan.
Cuando se termina de ejecutar alg´ un procedimiento, se recupera el registro que est´ a en la cima de la pila. En ese registro est´ an los valores de las variables como estaban antes de la llamada a la funci´ on, o algunas pueden haber cambiado si valor, dependiendo del ´ ambito de las variables.
Cada elemento en la pila que es retirado, significa que se ha terminado de ejecutar alguna funci´ on. Cuando se termina de ejecutar el programa, la pila de llamadas a subprogramas debe haber quedado en 0 tambi´ en, de otro modo podr´ıa causar algun tipo de error.
Esto nos lleva a pensar en otras utilidades de la pila. La pila sirve para en- contrar errores.
La din´ amica de la pila, es decir, la manera en c´ omo entran los datos a la estructura de datos y c´ omo salen, se denomina fifo, que viene del ing´ es first in first out (primero en entrar, primero en salir).
Figura 12. Din´ amica de la pila P
En la figura 12 se muestran “fotograf´ıas” en distintos momentos de la pila, cuando se desea insertar H justo debajo de F. Para hacer esto se requiere, retirar tantos elementos como sean necesarios, aqu´ı se han retirado de la cima G y F para luego insertar H, que quedar´ a posteriormente debajo de F.
Lo que sucede es que, cuando se retira el elemento G se debe hacer una evalu- aci´ on para determinar si el elemento retirado es el elemento objetivo, en este caso el elemento objetivo es F, puesto que se desea insertar un elemento debajo de F.
Despu´ es de haber insertado F, insertamos de nuevo los elementos F y G en ese
orden, adem´ as de insertar finalmente el elemento I que queda en la cima de la
pila. Enseguida veremos con m´ as detalle las operaciones b´ asicas de las pilas.
2.2. Operaciones b´ asicas
Las operaciones b´ asicas de una pila son:
1. En la pila S, insertar un elemento e: push(S,e), 2. Retirar un elemento de la pila S: pop(S),
3. Verificar si la pila S est´ a vac´ıa: stackempty(S) y
4. Saber cu´ al es el elemento en la cima de la pila S: stacktop(S).
enseguida cada una de estas operaciones:
2.2.1. La operaci´ on push
Esta operaci´ on sirve para insertar un elemento e en la pila S, lo vamos a escribir como:
push(S,e)
Despu´ es de hacer esta operaci´ on sucede que:
El elemento en la cima de la pila S ahora es e
2.2.2. La operaci´ on pop
Para retirar un elemento de la pila S y asignarlo a una variable del mismo tipo que el tipo de los elementos de la pila, usaremos la operaci´ on pop escribi´ endola como:
v=pop(S);
En donde v es una variable que almacena el valor del elemento que estaba en la cima de S. Hacer esta operaci´ on tiene algunas implicaciones:
La variable v debe ser del mismo tipo que los elementos almacenados en la pila.
Solamente se puede retirar un elemento de la pila a la vez.
Antes de la operaci´ on, e era el elemento en la cima, ahora ya no lo es m´ as.
El apuntador “cima” decrece en una unidad.
2.2.3. La operaci´ on stackempty
Esta operaci´ on toma como argumento una estructura del tipo stack (pila) y
devuelve un valor booleano, devuelve un true si la pila est´ a vac´ıa y devuelve
un false si la pila tiene al menos un elemento, es decir:
stackempty(S) =
true si S tiene 0 elementos
f alse si S tiene m´ as de 0 elementos
2.2.4. La operaci´ on stacktop
La operaci´ on stacktop(S) devuelve el valor del elemento en la cima de la pila S. Para hacer esta operaci´ on escribiremos:
v=stacktop(S)
las implicaciones de usar esta operaci´ on son:
Se hace una copia del elemento que est´ a en la cima
En realidad se hacen dos operaciones, primero se hace v=pop(S), luego un push(S,v), porque despu´ es de la operaci´ on stacktop, la pila S queda sin cambio alguno.
2.3. Ejemplo: N´ umero de par´ entesis
Supongamos ahora la expresi´ on ((5+6)*4)/(17+9), una de las condiciones para que sea una expresi´ on aritm´ etica correcta en que tengas sus par´ entesis balanceados, as´ı que deseamos saber si el n´ umero de par´ entesis que abres es el mismo n´ umero de par´ entesis que cierran.
Para resolver este problema usaremos el concepto de pila. La idea es simple.
Vamos a leer cada elemento de la expresi´ on, si se trata de un par´ entesis que abre, entonces lo insertaremos en una pila; si se trata de un par´ entesis que cierra, entonces sacamos un elemento de la pila. Al terminar de leer la expre- si´ on revisaremos si la pila est´ a vac´ıa, en cuyo caso habremos conclu´ıdo que el n´ umero de par´ entesis que abre es el mismo que el n´ umero de par´ entesis que cierra y la expresi´ on tiene par´ entesis balanceados.
Veamos c´ omo funciona:
‘(’ : push(S,‘(’)
‘(’ : push(S,‘(’)
‘5’ : nada que hacer
‘+’ : nada que hacer
‘6’ : nada que hacer
‘)’ : v=pop(S)
‘*’ : nada que hacer
‘4’ : nada que hacer
‘)’ : v=pop(S)
‘/’ : nada que hacer
‘(’ : push(S,‘(’)
‘17’: nada que hacer
‘+’ : nada que hacer
‘9’ : nada que hacer
‘)’ : v=pop(S)
Empezamos con un contador iniciado en 0, y por cada push aumentamos un contador, y por cada pop decrementamos el contador. Al final vemos el valor del contador, si el contador=0 entonces terminamos con ´ exito, de otro mod se˜ nalamos el error.
En la figura 13 se muestra la actividad de la pila a medida que se van agregando y quitando elementos.
Figura 13. Evaluaci´ on del balance de par´ entesis en una expresi´ on aritm´ etica
2.4. La estructura de datos Pila en C/C++
Una pila est´ a conformada por dos elementos:
Un espacio suficientemente grande para almacenar los elementos insertados en la pila
Una parte que nos se˜ nale cu´ al es el elemento en la cima de la pila.
Estas partes las conformamos en una estructura, descrita como sigue:
definir numero maximo de elementos en la pila definir nuevo tipo estructura llamado "stack" con
item : un arreglo de 1 a maximos elementos enteros
top : un numero de 0 a maximos elementos
fin de la nueva estructura
F´ acilmente podemos describir un c´ odigo en C/C++ que represente lo anterior- mente propuesto.
// En la parte de definiciones
#define maxElem 100 // En la parte de tipos struct stack {
int item[maxElem];
int top;
};
// En la parte de variables struct stack A;
2.5. La representaci´ on en C/C++ de las operaciones de una pila
En esta secci´ on veremos una implementaci´ on de las cuatro operaciones b´ asicas de las pilas. Todas estas operaciones se han hecho desde un punto de vista de programaci´ on funcional, sin duda se pueden describir en un modelo orientado a objetos.
2.5.1. La operaci´ on push
El siguiente segmento de c´ odigo ilustra c´ omo se puede implementar la op- eraci´ on insertar un elemento en una pila. Hemos supuesto que la pila ya est´ a definida como una estructura stack.
(1) void push(struct stack *S,int e){
(2) S->top++;
(3) S->item[S->top]=e;
(4) }
En la l´ınea (1) se observa que la operaci´ on push recibe dos par´ ametros: la direcci´ on de una estructura de tipo pila y un elemento de tipo entero.
La l´ınea (2) incrementa el tope (cima) de la pila en una unidad, con el fin de
agregar el elemento en una posici´ on libre de la pila, lo cual se logra en la l´ınea
(3), asignando el valor e en la casilla S->top del arreglo item de la pila.
2.5.2. La operaci´ on pop
La operaci´ on pop se escribe en forma de c´ odigo en C/C++ con la siguiente secuencia de ´ ordenes:
(1) int pop(struct stack *S){
(2) int valReturn;
(3)
(4) valReturn=S->item[S->top];
(5) S->top--;
(6) return valReturn;
(7) }
La l´ınea (1) describe que esta funci´ on devuelve un tipo entero, el tipo de elementos guardados en la pila; luego notamos que debemos dar s´ olo la direc- ci´ on de alguna variable de tipo estructura de pila (struct stack *). Obtener la direcci´ on se logra con el operador de indirecci´ on (&).
Las l´ıneas (4) y (5) hacen todo el trabajo de esta funci´ on, se almacena el valor que ser´ a devuelto en una variable de tipo entero y luego se decrementa el tope de la pila.
2.5.3. La operaci´ on stackempty
La operaci´ on stackempty se describe en el siguiente segmento de c´ odigo:
(1) bool stackempty(struct stack *S){
(2) bool valorDevuelto;
(3) if(S->top== -1)
(4) valorDevuelto=true;
(5) else
(6) valorDevuelto=false;
(7) return valorDevuelto;
(8) }
El encabezado de la funci´ on que se muestra en la l´ınea (1) establece que se devuelve un valor booleano, y que se debe dar un par´ ametro, que es la direcci´ on de una localidad de memoria que almacena una estructura de tipo pila. El objetivo de esta funci´ on es claro:
La l´ınea (3) establece la verdacidad o falsedad del predicado (S->top==-1),
determinando si el nivel del tope es igual que -1, en cuyo caso devuelve un
verdadero (4), de otro modo ha de devolver un valor falso (6). Se ha establecido
un -1 como vac´ıo porque el manejo de arreglos en C/C++ empieza en el ´ındice
0, que a diferencia de otros lenguajes como Pascal, empiezan en 1.
2.5.4. La operaci´ on stacktop
Este es un caso especial porque no se requiere hacer ning´ un c´ odigo.
Esta funci´ on debe devolver un n´ umero entero y dejar la pila sin cambio. Para lograr esto se debe hacer un pop(&A), mostrar el elemento y luego insertar de nuevo el elemento en la pila haciendo un push(&A,elemento), notemos que se han usado los operadores de direcci´ on para dar la direcci´ on de la variable que alberga una estructura de tipo pila. El siguiente segmento de c´ odigo ilustra c´ omo se han usado las funciones antes creadas, por supuesto que se pueden separar y crear una nueva funci´ on que haga lo mismo:
...
(1) case 4:{
(2) if(not stackempty(&A)){
(3) valor=pop(&A);
(4) std::cout<<"La cima de la pila es: "<<valor<<"\n";
(5) push(&A,valor);
(6) } else
(7) std::cout<<"La pila esta vacia";
(8) break;
(9) } ...
2.6. Problemas de programaci´ on
Los siguientes ejercicios deben ser resueltos en un progr´ ama (en C/C++ ):
1. Expresiones entrefijas y prefijas. Las expresiones aritm´ eticas pueden representarse de varias maneras, una de ellas, la m´ as usual es la notaci´ on entrefija.
La notaci´ on entrefija establece que en medio de dos operandos se escribe un operador, como por ejemplos:
a) a ∗ b, donde los operandos son a y b, y el operador es el s´ımbolo ∗;
b) 2 + 5 ∗ ((5 + 7)/4) Donde el par´ entesis m´ as interno establece la may- or prioridad, de manera que primero se debe evaluar (5 + 7), luego (12/4), luego 2 + (5 ∗ 3) y fimalmente (2 + 15), dando como resultado 17.
c) −1 No hay nada que hacer, pues es un operador unario.
En las expresiones prefijas se establece que el orden de escritura debe ser, primero el operador y luego la lista de operandos:
a) ∗ab, donde los operandos son a y b, y el operador es el s´ımbolo ∗;
b) +2 ∗ 5/ + 574 Lo primero que hay que hacer es tomar el primer
operador y tomar los operandos necesarios siguientes (dos si se trata de un operador binario y uno si es un operador unario). En este caso se trata de evaluar 2 + [∗5/ + 574]. Cada uno de los operandos debe ser tratado de nuevo como una expresion en prefijo, de manera que se repite lo anterior, tomar el operador y la lista de sus operandos y tratar cada uno de sus operandos como expresiones en prefijo: 2 + [5 ∗ [/ + 574]], luego 2 + [5 ∗ [[+57]/4]] y finalmente 2 + [5 ∗ [[5 + 7]/4]]
y evaluar. Los par´ entesis cuadrados son para ilustrar el ejemplo y no son necesarios para su evaluaci´ on.
c) −1 No hay nada que hacer, pues es un operador unario.
Haga un programa en C/C++ que transforme expresiones de entrefijo a prefijo, y de prefijo a entrefijo. Los caracteres v´ alidos son: las letras may´ usculas y min´ usculas, los n´ umeros enteros, los par´ entesis normales, los cuatro operadores (+, −, ∗, /, ) y el operador unario (−).
Figura 14. Ilustraci´ on del estacionamiento mencionado en el problema 2 2. en cierto punto de la ciudad hay un estacionamiento como el que se
muestra en la figura 14, en donde hay lugar para 9 veh´ıculos. haga un programa que muestre el manejo de este estacionamiento, considerando los siguientes requisitos:
a) Los veh´ıculos proporcionan la siguiente informaci´ on: Placas (6 digi- tos), Estado (2-3 caracteres, p.e. SON, DF, CHI, YUC), Marca, Mod- elo, A˜ no-Modelo, Nombre del propietario.
b) Al llegar un ve´ıculo se acepta solamente si hay lugar disponible.
c) Validar todas las operaciones de la pila.
d ) En cualquier momento se puede sacar alg´ un veh´ıculo del estacionamien- to, regresando los veh´ıculos en el orden en que estaban.
e) Toda la corrida del programa debe hacerse hacia/desde la terminal est´ andar.
3. Haga un programa que implemente 2 pilas en 1 arreglo A[1..n] de man-
era que ninguna pila se desborde a menos que el n´ umero de elementos en
ambas pilas sea n
3. Colas
Definici´ on 5 Las colas son una estructura de datos similar a las pilas. Recorde- mos que las pilas funcionan en un dep´ osito en donde se insertan y se retiran elementos por el mismo extremo. En las colas sucede algo diferente, se inser- tan elementos por un extremo y se retiran elementos por el otro extremo. De hecho a este tipo de dispositivos se les conoce como dispositivos “fifo” (first in, first out) porque funcionan como una tuber´ıa, lo que entra primero por un extremo, sale primero por el otro extremo.
En una cola hay dos extremos, uno es llamado la parte delantera y el otro extremo se llama la parte trasera de la cola. En una cola, los elementos se retiran por la parte delantera y se agregan por la parte trasera.
Figura 15. Din´ amica de una cola. a) estado actual con una cola con tres elementos a,b,c; b) estado de la cola cuando se agrega el elemento d; c) estado de la cola cuando se elimina el elemento a del frente de la cola
En la figura 15 se muestra una actividad t´ıpica de la cola, en donde se muestra que se agregan datos por la parte trasera de la cola y se eliminana datos por el frente de la cola.
Si Q es una cola y x es un elemento, se pueden hacer tres operaciones b´ asicas con las colas:
1. insert(Q,x), que inserta el elemento x en la parte trasera de la cola Q.
2. x=remove(Q), que almacena en x el valor del elemento retirado de la parte frontal de la cola Q.
3. empty(Q), que es un predicado de valor booleano, y es verdadero cuando
la cola Q tiene 0 elementos, y es f also cuando la cola Q tiene al menos un
elemento, en cuyo caso, ese ´ unico elemento es la parte frontal y la parte
trasera de la cola al mismo tiempo.
Te´ oricamente no hay l´ımite para el tama˜ no de la cola, asi que siempre se deber´ıa poder insertar elementos a una cola, sin embargo, al igual que las pilas, normalmente se deja un espacio de memoria para trabajar con esta estructura. Por el contrario, la operaci´ on remove s´ olamente se puede hacer si la cola no est´ a vac´ıa.
3.1. Estructura de las colas en C/C++
De manera similar a las pilas, las colas definen una estructura no est´ andar, de manera que se debe crear un nuevo tipo de dado, el tipo cola, que debe tener los siguientes elementos:
Un arreglo de n elementos de alg´ un tipo espec´ıfico, puede incluso ser un tipo est´ andar o no.
Un n´ umero que indica el elemento que est´ a en la posici´ on del frente de la cola.
Un n´ umero que indica el elemento que est´ a en la posici´ on trasera de la cola.
Suponiendo que los elementos son n´ umeros enteros, una idea para representar una cola en C/C++ es usar un arreglo para contener los elementos y emplear otras dos variables para representar la parte frontal y trasera de la cola.
#define maxQueue 100 struct cola{
int items[maxQueue];
int front;
int rear;
};
Esta representaci´ on con arreglos es completamente v´ alida, pero debemos tener cuidado con los l´ımites del arreglo. Suponiendo que no existiera la posibilidad de caer en un desbordamiento del arreglo, es decir, que se insertaran m´ as elementos de lo que el arreglo puede almacenar, la operaci´ on insert podr´ıa quedar como:
void insert(struct cola *C, int e){
C->items[++C->rear]=e;
}
y al operaci´ on x=remove(Q) int remove(struct cola *C){
return C->items[C->front++];
}
y finalmente la operaci´ on empty(Q):
bool empty(struct cola *C){
if(C->front>C->rear) return true;
else
return false;
}
3.2. Colas con prioridad
Una cola con prioridad es una estructura de datos en la que se ordenan los datos almacenados de acuerdo a un criterio de prioridad. Hay dos tipos de colas de prioridad:
Las colas de prioridad con ordenamiento descendente.
Las colas de prioridad con ordenamiento ascendente.
En las colas de prioridad ascendente se pueden insertar elementos en forma arbitraria y solamente se puede remover el elemento con menor prioridad. Si CPA es una cola de prioridad ascendente, la operaci´ on insert(CPA,x) inserta el elemento x en la cola CPA; y la operaci´ on x=minRemove(CPA) asigna a x el valor del elemento menor (de su prioridad) y lo remueve de la cola.
En las colas de prioridad descendente es similar, pero s´ olo permite la supresi´ on del elemento m´ as grande. Las operaciones aplicables a la cola de prioridad descendente son insert(CPD,x) y x=maxRemove(CPD), cuando CPD es una cola de prioridad descendente y x es un elemento.
La operaci´ on empty(C) se aplica a cualquier tipo de cola y determina si una cola de prioridad est´ a vac´ıa. Las operaciones de insertar y borrar se aplican solamente si la pila no est´ a vac´ıa.
Los elementos de la cola de prioridad no necesitan ser n´ umeros o caracteres para que puedan compararse directamente. Pueden ser estructuras complejas ordenadas en uno o varios campos. Por ejemplo, las agendas telef´ onicas constan de apellidos, nombres, direcciones y n´ umeros de tel´ efono y est´ an ordenadas por apellido.
A diferencia de las pilas y las colas, en las colas de prioridad se pueden sacar
los elementos que no est´ an en el primer sitio del extremo donde salen los
elementos. Esto es porque el elemento a retirar puede estar en cualquier parte
del arreglo.
Cuando se requiere eliminar un dato de una cola de prioridad se necesita verificar cada uno de los elementos almacenados para saber cu´ al es el menor (o el mayor). Esto conlleva algunos problemas, el principal problema es que el tiempo necesario para eliminar un elemento puede crecer tanto como elementos tenga la cola.
Para resolver este problema hay varias soluciones:
1. Se coloca una marca de “vac´ıo” en la casilla de un elemento suprimido.
Este enfoque realmente no es muy bueno, porque de cualquier modo se accesan los elementos para saber si es una localidad vac´ıa o no lo es. Por otro lado, cuando se remueven elementos, se van creando lugares vac´ıos y despu´ es es necesario hacer una compactaci´ on, reubicando los elementos en el frente de la cola.
2. Cada supresi´ on puede compactar el arreglo, cambiando los elementos depu´ es del elemento eliminado en una posici´ on y despu´ es decrementando rear en 1. La inserci´ on no cambia. En promedio, se cambian la mitad de los elementos de una cola de prioridad para cada supresi´ on, por lo que esta operaci´ on no es eficiente.
3.3. Ejercicio de programaci´ on
1. Modifique los procedimientos de insertar, retirar y verificar-cola-vac´ıa para que considere aprovechar los espacios dejados al retirar elementos.
2. Un deque es un conjunto ordenado de elementos del cual pueden elimi- narse elementos en cualquier extremo y en el cual pueden insertarse ele- mentos en cualquier extremo. Llamemos a los dos extremos de un deque left (izquierdo) y right (derecho). ?’c´ omo se representa un deque en un arreglo en C/C++ ? escriba un programa que maneje un deque, y que considere las cuatro rutinas
removeLeft removeRight insertLeft insertRight
para remover e insertar elementos en los extemos izquierdo y derecho de un deque. Aseg´ urese de que las rutinas funcionan adecuadamente para que un deque vac´ıo y que detectan desbordamiento y subdesbordamiento.
3. Programe las colas de prioridad ascendente y descendente.
4. Existe un estacionamiento que tiene un s´ olo carril que aloja hasta 10
carros. Los autos llegan por el extremo sur del estacionamiento y salen por el extremo norte del mismo. Si llega un cliente para recoger un carro que no est´ a en el extremo norte, se sacan todos los autom´ oviles de ese lado, se retira el auto y los otros coches se restablecen en el mismo orden que estaban. Cada vez que sale un auto, todos los autos del lado sur se mueven hacia adelante para que en todas las ocasiones todos los espacios vac´ıos est´ en en la parte sur del estacionamiento. Escriba un programa que lea un grupo de lineas de ingreso. Cada l´ınea contiene una “A” para las llegadas y una “D” para las salidas y un n´ umero de placa. Se supone que los carros llegan y salen en el orden especificado en la entrada. El programa debe imprimir (en la terminal est´ andar) un mensaje cada vez que entra o sale un auto. Cuando llega un carro, el mensaje debe especificar si hay espacio o no para ´ el en el estacionamiento. Si no hay espacio, el carro espera hasta que hay espacio o hasta que se lee una l´ınea de salida para el auto. Cuando queda disponible espacio, debe imprimirse otro mensaje.
Cuando salga un coche, el mensaje debe incluir la cantidad de veces que
se movi´ o el auto dentro del estacionamiento, incluyendo la salida misma,
pero no la llegada. Este n´ umero es 0 si el carro sale de la fila de espera.
4. Recursi´ on
Un tema fundamental para los pr´ oximos temas es el de recusri´ on. La recursi´ on es muy importante tanto en mate´ aticas como em computaci´ on, pues se usa recursi´ on para definir procedimientos autosimilares.
Definici´ on 6 Decimos que un objeto es recursivo si en su definici´ on se nom- bra a s´ı mismo.
En programaci´ on, una funci´ on es recursiva si en el ´ ambito de esa funci´ on hay una llamada a s´ı misma, C/C++ permite esta clase de acciones. Los algoritmos recursivos dan elegancia a las soluciones de los problemas. Un ejemplo cl´ asico es el factorial de un n´ umero.
Una manera de definir el factorial de un n´ umero n > 1 es:
!n =
n
Y
i=1
i,
es decir, el producto de todos los n´ umeros enteros menores o guales que ´ el, lo que se puede resolver f´ acilmente con una funci´ on iterativa, esto es, una funci´ on con un ciclo que itere suficientes veces, incrementando un valor y entonces ir almacenando en una variable el resultado de esas multiplicaciones.
Una implementaci´ on de esta definici´ on iterativa es:
(1) int i,n;
(2) long double valorAc;
(4) valorAc=1.0;
(5) std::cout << "Numero entero:";
(6) std::cin>> n;
(7) for(i=1; i<=n; i++) valorAc = valorAc*i;
(8) std::cout<<"El factorial de "<<n<<" es:"<<valorAc;
El ciclo principal es en la l´ınea (7). No hay ning´ un truco hasta aqu´ı. La
´
unica observaci´ on importante es en la l´ınea (2) en donde se declara el tipo long double para el valor del resultado, la raz´ on para tal acci´ on es que el n´ umero factorial crece muy r´ apido y a´ un con entradas en el rango de los caracteres (hasta 255), el factorial es muy grande. Este procedimiento com- putacional no hace uso de t´ ecnicas especiales empleadas para tratar n´ umeros grandes.
Sin embargo una soluci´ on m´ as elegante es usar la definici´ on recursiva, y esta
es:
!n = n ∗ !(n − 1)
El programa en C/C++ es el que se muestra a continuaci´ on:
( 1) double factorial(double a){
( 2) if (a<=1) return 1.0;
( 3) else return (a *factorial(a-1.0)); } ( 4)
( 5) int main (int argc, char * const argv[]) { ( 6) double n;
( 7) std::cout << "Numero entero:";
( 8) std::cin>> n;
( 9) std::cout<<"El factorial de "<<n<<" es: "<< factorial(n);
(10) return 0; }
Aqu´ı hay varias cosas que se˜ nalar, en primer lugar se ha creado una nueva funci´ on, a diferencia de la definici´ on iterativa en donde era suficiente traba- jar en el programa principal. Esta funci´ on se llama factorial (como era de suponerse), y empieza su encabezado en la l´ınea (1).
All´ı mismo en la misma l´ınea (1), es de notar que hemos emplado ahora el tipo double tanto para el tipo devuelto como para el tipo del argumento, a diferencia de la versi´ on iterativa en donde emple´ abamos tipos diferentes. La raz´ on es que al iniciar la recursi´ on el argumento es del tipo devuelto, asi que deben ser del mismo tipo.
Cada llamada recursiva genera una entrada a una pila, en donde se guardan (como elementos) los estados generales del sistema al momento de hacer la llamada, entonces, cuando se termina la funci´ on se recupera una entrada de la pila. En la figura 16 ilustra c´ omo funciona la recursividad cuando se intenta obtener el factorial(5).
Figura 16. Recursividad cuando se ejecuta factorial(5)
4.0.1. La serie Fibonacci
Una de las series m´ as famosas es sin duda alguna la serie de Fibonacci:
1, 1, 2, 3, 5, 8, 13, 21, 34, . . .
Un poco de observaci´ on es sufucuente para encontrar que cualquier n´ umero (a partir del tercero de la serie, osea el segundo 1) es igual a la suma de los dos n´ umeros anteriores.
Daremos en primer lugar la versi´ on iterativa. En este algoritmo deseamos encontrar el n-´ esimo n´ umero de la serie Fibonacci. As´ı si n = 4 el resultado del algoritmo debe ser 3; si n = 6 el resultado debe ser 8. La versi´ on iterativa empieza desde los primeros 1’s, sum´ andolos y encontrando el tercero, luego para encontrar el cuarto n´ umero se suman el tercero (reci´ en encontrado) y el segundo, y as´ı en adelante hasta encontrar el n´ umero buscado.
#include <iostream>
int main (int argc, char * const argv[]) { int i,n,fib,fib1,fib2,fibx;
std::cout<<"Un numero entero:";
std::cin>>n;
fib1=2; fib2=1; i=3;
if((n==1)||(n==2)) fib=1;
else{
do{
fib = fib1 + fib2;
fibx = fib1; i++;
fib1 = fib; fib2 = fibx;
}while(i<n);
}
std::cout << "\nEl "<<n<<"-esimo numero de la serie Fibonacci es: "<<fib;
return 0;
}
La definici´ on recursiva para encontrar todos los n primeros n´ umeros de la serie
Fibonacci es:
fib(n) =
