Beruflich Dokumente
Kultur Dokumente
FACULTAD DE INGENIERÍA
CARRERA PROFESIONAL DE INGENIERIA DE SISTEMAS E INFORMATICA
SÍLABO DE LA ASIGNATURA:
ALGORITMOS Y ESTRUCTURA DE DATOS
SEMESTRE ACADÉMICO 2009-I
I. DATOS GENERALES
1.1. Nombre de la asignatura : Algoritmos y Estructura de Datos I
1.2. Nombre de la Facultad : Facultad de Ingeniería
1.3. Carrera Profesional : Ingeniería de Sistemas e Informática
1.4. Nivel de estudios : III semestre
1.5 Código de la Asignatura : SI032
1.6. Pre_requisito : SI021
1.7. Semestre Académico : 2009-I
1.8. Nro. de hrs. semanales : 5 hrs.
1.9. Duración de la Asignatura : 17 semanas
1.10. Créditos : 4 créditos
1.11. Categoría de la asignatura : FICI
1.12. Profesor : Ing. Reynaldo Miranda Pomacondor
1.13. Horario : LU – MA 07:00 – 9:00; Vi 09:00 – 10:00
II. SUMILLA
III. OBJETIVOS
General:
Los alumnos al finalizar el curso estarán en la capacidad de elaborar algoritmos que
resuelvan problemas de propósito general.
Específicos:
1. Presentar la diversidad de los algoritmos y sus aplicaciones.
2. Aplicar los Algoritmos Estructurados (Programación Estructurada) para la solución de
problemas.
3. Optimizar los algoritmos estructurados de forma que sean más simples y eficientes.
Primera Semana:
Introducción.
Definiciones Básicas:
• Concepto de Datos – Tipos de datos.
• Operadores: Aritméticos, Lógicos y de Comparación.
• Identificadores: Concepto, Constantes, Variables. Operador de Asignación,
Acumulador y Contador.
Segunda Semana:
Estructuras de Control:
• Secuenciales.
• Selectivas: Simples y Múltiple.
• Estructuras Selectivas Anidadas.
Tercera Semana:
• Repetitivas (Bucles): Bucle con número de repeticiones pre-establecido, Bucle con
entrada controlada y Bucle con salida controlada.
• Estructuras Repetitivas Anidadas.
• Aplicaciones.
Cuarta Semana:
Arreglos:
• Vectores: Creación, asignación, lectura y escritura.
• Operaciones con vectores: Búsqueda, Ordenamiento, Eliminación e Inserción.
Quinta Semana:
• Matrices: Creación, asignación, lectura y escritura.
• Operaciones con matrices.
Sexta Semana:
Cadenas:
• Creación y uso.
• Operaciones con cadenas.
• Arreglo de cadenas. Aplicaciones.
Séptima Semana:
Subprogramas:
• Funciones: Creación y uso.
• Variables globales y Locales.
• Aplicaciones.
Novena Semana:
• Procedimientos: Creación y uso.
• Parámetros por referencia o valor.
• Aplicaciones.
Décima Semana:
Recursividad:
• Funciones recursivas.
• Procedimientos recursivos.
• Aplicaciones.
2
Décimo Segunda Semana:
Archivos de Acceso Aleatorio:
• Creación y uso.
• Operaciones con archivos: Lectura – escritura, búsqueda y ordenamiento.
• Aplicaciones.
V. METODOLOGÍA
Las clases serán desarrolladas en forma teórico – práctica, induciendo en el alumnos los
conceptos mediante comparación de hechos reales. Se pondrá énfasis en la participación
de los alumnos en la resolución de problemas planteados en clase.
Para el desarrollo de las clases se utilizará por lo general pizarra y tizas. Se entregará una
serie de ejercicios relacionados con los temas del curso
3
VII. EVALUACIÓN
VIII.BIBLIOGRAFIA
4. Metodología de la Programación.
Luis Joyanes Aguilar.
Editorial Mc. Graw Hill.
8. Estructuras de Datos.
Cairó – Guardate.
Editorial Mc. Graw Hill 2001.
4
UNIVERSIDAD TECNOLOGICA DE LOS ANDES
FACULTAD DE INGENIERÍA
CARRERA PROFESIONAL DE INGENIERIA DE SISTEMAS E INFORMATICA
Los apuntadores se pueden usar para permitir que una función reciba y cambie el valor de
una variable. Esto permite evitar la necesidad de declarar variables globales.
Los apuntadores también son utiles para asignar memoria mientras el programa esta
corriendo.
Ojo, para accesar el valor de una variable a través del apuntador a ella, precede el
apuntador con un asterisco. Por ejemplo, cout<<*cadena , nos va a mostrar el valor del
caracter almacenado en esa dirección. Este valor es alcanzado en forma indirecta a través
de un apuntador, a este proceso se le llama indirección o deferenciación.
Inicialización dinámica.
struct lista {
gint dato;
lista *siguiente;
};
Representa el dato a almacenar. Puede ser de cualquier tipo; en este ejemplo se trata de
una lista de
enteros. Es un puntero al siguiente elemento de la lista; con este puntero enlazamos con el
sucesor, de forma que podamos construir la lista.
Para que esta estructura sea un TDA lista enlazada, debe tener unos operadores asociados
que permitan la manipulación de los datos que contiene. Los operadores básicos de una
lista enlazada son:
• Insertar: inserta un nodo con dato x en la lista, pudiendo realizarse esta inserción al
principio o final de la lista o bien en orden.
• Eliminar: elimina un nodo de la lista, puede ser según la posición o por el dato.
• Buscar: busca un elemento en la lista.
• Localizar: obtiene la posición del nodo en la lista.
• Vaciar: borra todos los elementos de la lista
Después de esta breve introducción, que sólo pretende servir como recordatorio, pasaremos
a ver cómo es la estructura GSList que, junto con el conjunto de funciones que la
acompañan, forman el TDA lista enlazada en GLib™.1
GSList
1
Manual de Referencias GNOME Documentation Library http://library.gnome.org/devel/glib/unstable/index.html
La definición de la estructura GSList o, lo que es lo mismo, un nodo de la lista, está definido
de la siguiente manera:
struct GSList {
gpointer data;
GSList *next;
};
Representa el dato a almacenar. Se utiliza un puntero genérico por lo que puede almacenar
un puntero a cualquier tipo de dato o bien almacenar un entero utilizando las macros de
conversión de tipos. Se trata de un puntero al siguiente elemento de la lista. Las macros de
conversión disponibles son las siguientes:
GINT_TO_POINTER ()
GPOINTER_TO_INT ()
GUINT_TO_POINTER ()
GPOINTER_TO_UINT ()
Más adelante, en esta misma sección, se verán ejemplos del uso de estas macros.
Las funciones que acompañan a la estructura GSList y que implementan los operadores
básicos de las listas enlazadas, son las siguientes:
Las dos funciones expuestas para la eliminación de nodos, si bien tienen una definición
prácticamente idéntica, el resultado obtenido es distinto. En el caso de g_slist_remove, se
eliminará el nodo que contenga el valor data.Si hay varios nodos con el mismo valor, sólo se
eliminará el primero. Si ningún nodo contiene ese valor, no se realiza ningún cambio en el
GSList. En el caso de g_slist_remove_all, se eliminan todos los nodos de la lista que
contengan el valor data y nos devuelve la nueva lista resultante de la eliminación de los
nodos.
if (list2 != NULL) {
g_print ("\nEl dato %d sera eliminado de la lista.\n", list2->data);
/* eliminando un elemento de la lista */
g_slist_remove (list, list2->data); }
Tabla 3. Operadores de búsqueda en listas enlazadas.
Operador Funciones asociadas a GSList.
Buscar un nodo según un valor. GSList* g_slist_find (GSList *list, gconstpointer data)
GSList* g_slist_find_custom (GSList *list, gconstpointer
Buscar un nodo según un criterio.
data, GCompareFunc func)
Localizar el índice de un nodo. GSList* g_slist_index (GSList *list, gconstpointer data)
Localizar la posición de un nodo. GSList* g_slist_position (GSList *list, GSList *llink)
Obtener el último nodo. GSList* g_slist_last (GSList *list)
Obtener el siguiente nodo. g_slist_next (slist)
Obtener un nodo por su posición. GSList* g_slist_nth (GSList *list, guint n)
Obtener el dato de un nodo según
gpointer g_slist_nth_data (GSList *list, guint n)
su posición.
2
Idem 1
Listas Doblemente Enlazadas.
Introducción.
El TDA lista doblemente enlazada, al igual que la lista enlazada, es un TDA dinámico lineal
pero, a diferencia de este, cada nodo de la lista doblemente enlazada contiene dos
punteros, de forma que uno apunta al siguiente nodo y el otro al predecesor. Esta
característica, permite que se pueda recorrer la lista en ambos sentidos, cosa que no es
posible en las listas simples.
GList
La definición de la estructura GList, que es un nodo de la lista doblemente enlazada, está
definido de la siguiente manera:
struct GList {
gpointer data;
GList *next;
GList *prev;
};
Representa el dato que se va a almacenar. Se utiliza un puntero genérico por lo que puede
almacenar un puntero a cualquier tipo de dato o bien almacenar un entero utilizando las
macros de conversión de tipos.
Se trata de un puntero al siguiente elemento de la lista.
Se trata de un puntero al elemento anterior de la lista.
Las funciones que acompañan a la estructura GList, que implementan los operadores
básicos de las listas enlazadas, son las siguientes:
3
Idem 1
ListaSimple
/*********************************************************
* Archivo: ListaSimple.java
* Lenguaje: Java
* UNIVERSIDAD TECNOLOGICA DE LOS ANDES
* Notas:
*********************************************************/
//Constructor
public boolean VaciaLista(){
return PrimerNodo ==null;
}
//Contructor
public ListaSimple(String s){
Nombre=s;
PrimerNodo=UltimoNodo=null;
}
//Constructor
public ListaSimple(){
this ("Lista");
}
if(enc==true){
if (aux.equals(PrimerNodo)){
PrimerNodo=aux.siguiente;
}
else{
if (aux.equals(UltimoNodo)){
UltimoNodo=ant;
ant.siguiente=null;
}
else{
NodosLista i=aux.siguiente;
aux=ant;
aux.siguiente=i;
PrimerNodo=p;
}
}
}
}
class ListaSimpleA{
public static void main (String [] args){
ListaSimple l=new ListaSimple();
//Crea la lista
l.InsertaInicio("7");
l.InsertaInicio("3");
l.InsertaInicio("16");
l.InsertaInicio("2");
l.InsertaInicio("5");
l.InsertaInicio("8");
l.InsertaInicio("10");
l.InsertaInicio("15");
l.InsertaInicio("1");
l.Imprimir();
}
}
Página 4
FUENTES DE CONSULTA
BIBLIOGRAFIA
DALE, Nell / WEEMS, Chip. PROGRAMACIÓN Y RESOLUCIÓN DE PROBLEMAS CON C++.
Cuarta edición. Editorial McGraw Hill, México, 2007.
DEITEL, Harvey M. / DEITEL, Paul J. CÓMO PROGRAMAR EN C++ Y JAVA. Cuarta Edición.
Editorial Pearson Prentice Hall, México, 2004.
SITIOS WEB
http://www.romalo.250x.com/contenido/ci/index15.htm
http://www.infonet.com.ve/informaciongeneral/tecnologiagsm/default.aspx
http://microasist.com.mx/noticias/internet/fimin271003.shtml
http://www.ericsson.com.mx/press/referencias/tec_gsm.html