Repblica Bolivariana de Venezuela.

Ministerio del Poder Popular para la Defensa Universidad Nacional Experimental de la Fuerza Armada Anlisis y diseo de sistemas. Ciudad Bolvar Estado Bolvar.

Estructuras Dinmicas de Datos

Facilitador: Denis Acosta

Bachiller: Elvis Martnez C.I: 23.729.994

Ciudad Bolvar, Junio del 2013

ndice.
Introduccin. ................................................................................................................................. 3 Pilas: Definicin y operaciones sobre pilas, ejemplos. Pilas alojadas en arreglos. Implantacin de procedimientos recursivos mediantes pilas............................................................................. 4 Colas: Definicin y operaciones con colas, ejemplos. Colas circulares, Doble cola y aplicaciones. ....................................................................................................................................................... 8 Listas: Definicin, tipos y operaciones con listas, Aplicaciones, Representacion. Ejemplo. ....... 17 Listas enlazadas lineales ...................................................................................................... 17 Listas enlazadas circulares................................................................................................... 17 Conceptos Avanzados: Excepciones, Multith Reading ................................................................ 20 Fundamentos de la programacin avanzada orientada a objeto : utilizacin de estructuras dinmicas de datos y operaciones de entrada y salida............................................................... 22 Conclusin. .................................................................................................................................. 28 Bibliografa. ................................................................................................................................. 29

Introduccin.

En el universo de la programacin actual, es de amplio consenso que la programacin orientada a objetos es el mejor paradigma disponible para enfrentar las cada vez ms complejas tareas de la programacin. Sin embargo, no todos los programadores tienen claro los fundamentos de este paradigma, y tienden a confundir la programacin usando objetos con la programacin orientada a objetos.

En Visual Basic, por ejemplo, se usan objetos (componentes) sin que ello implique que estemos en presencia de un lenguaje orientado a objetos. Programamos orientado a objetos cuando, usando un lenguaje de programacin, somos capaces de modelar el problema en trminos de objetos y sus relaciones. Es decir cuando cada entidad en el programa es un objeto que brinda determinados servicios.

En este trabajo se hace una sucinta descripcin de los fundamentos de la programacin orientada a objetos, necesaria para aquellos que no poseen nociones sobre esta materia, y material de consulta para los que la conocen o dominan.

Pilas: Definicin y operaciones sobre pilas, ejemplos. Pilas alojadas en arreglos. Implantacin de procedimientos recursivos mediantes pilas.

Definicin:

Se comienza definiendo lo que es una pila a nivel de programacin; Pila es una estructura de datos en la que la insercin y la extraccin de elementos se realizan slo por un extremo que se denomina cabeza. Como consecuencia, los elementos de una pila sern eliminados en orden inverso al que se insertaron. Es decir, el ltimo elemento que se meti en la pila ser el primero en salir de ella.

Debido al orden en que se insertan y eliminan los elementos en una pila, tambin se le conoce como estructura lifo (last in, first out: ltimo en entrar, primero en salir).

Ejemplo grafico:

Operaciones:

Una pila es una estructura de datos homognea (elementos del mismo tipo), secuencial y de tamao variable. Slo es posible un modo de acceso a esta estructura: a travs de la cabeza de la pila. De este modo podemos aadir un elemento a la cabeza de la pila o extraer un elemento de la cabeza de la pila. Debido a que las operaciones de extraccin e insercin se realizan por el mismo extremo, el ltimo elemento en ser aadido ser el primero en ser extrado; por ello a estas estructuras se las conoce con el nombre de LIFO (last-in, first-out; ltimo en entrar, primero en salir). La pila es una lista de elementos caracterizada porque las operaciones de insercin y eliminacin de elementos

se realizan solamente en un extremo de la estructura. El extremo donde se realizan estas operaciones se denomina habitualmente cima (top en la nomenclatura inglesa). Dada una pila P, formada por los elementos a, b, c, ..., k (P=(a,b,c,...,k)), se dice que a, que es el elemento ms inaccesible de la pila, est en el fondo de la pila (bottom) y que k, por el contrario, el ms accesible, est en la cima (top).

Las restricciones definidas para la pila implican que si una serie de elementos A, B, C, D, E, F se aaden, en este orden, a una pila entonces el primer elemento que se elimine (borre) de la estructura deber ser E. Por tanto, resulta que el ltimo elemento que se inserta en una pila es el primero que se borra. Por esa razn, se dice que una pila es una lista o estructura lineal de tipo LIFO (Last In First Out, el ltimo que entra es el primero que sale).

Ejemplos:

Un ejemplo tpico de pila lo constituye un montn de platos: Cuando se quiere introducir un nuevo plato, ste se coloca en la posicin ms accesible, encima del ltimo plato. Cuando se coge un plato, ste se extrae, igualmente, del punto ms accesible, el ltimo que se ha introducido. O, si somos ms estrictos, otro ejemplo sera una caja llena de libros. Slo podemos ver cul es el libro que est ms arriba en la caja, y si ponemos o cojemos un libro, slo podremos actuar sobre este primer libro. No podemos siquiera saber el nmero total de libros guardados en la pila. Slo sabremos el nmero de elementos de la pila de libros si previamente los sacamos hasta vaciar la caja. Otro ejemplo natural de la aplicacin de la estructura pila aparece durante la ejecucin de un programa de ordenador, en la forma en que la mquina procesa las llamadas a los procedimientos.

Cada llamada a un procedimiento (o funcin) hace que el sistema almacene toda la informacin asociada con ese procedimiento (parmetros, variables, constantes, direcin de retorno, etc...) de forma independiente a otros procedimientos y permitiendo que unos procedimientos puedan invocar a otros distintos (o a si mismos) y que toda esa informacin almacenada pueda ser recuperada convenientemente cuando corresponda.

Pilas alojadas en arreglos:

Resulta conveniente el almacenamiento secuencial para el tratamiento de pilas. Podemos tener una variable llamada TOPE que contenga el ndice donde est ubicado el tope de la pila. Cuando la pila est vaca, hacemos TOPE=0. Por ej.: podemos definir una constante llamada CANTELEMENTOS que tenga el valor mximo de elementos que podr contener la pila, un tope con la ltima posicin, un Valor a ser ingresado y el arreglo mismo:

#define CANTELEMENTOS 10; int tope = -1; /*inicializamos a la variable tope con el valor 1 para que represente a la pila vaca porque el 1 elemento tiene ndice 0.*/ int pila[CANTELEMENTOS]; int valor;

Para dar un ejemplo sencillo: suponte que tienes una pila de 10 platos. El primer plato de la pila ser el ltimo en quitarse y el ltimo plato de la pila ser el primero en quitarse.

Implantacin de procedimiento recursivo mediante pilas:

Bajo una llamada recursiva el sistema reserva espacio (tabla de activacin) donde almacenar una copia de los objetos locales y parmetros del subprograma en ese momento. La tabla de activacin se amontona sobre las llamadas recursivas anteriores formando lo que se conoce como pila recursiva.

 Este proceso termina cuando un nuevo valor del parmetro no produce una nueva llamada recursiva (se alcanza el caso base). Una vez alcanzada esta situacin el sistema va liberando el espacio reservado conforme los subprogramas se van ejecutando sobre su tabla de activacin. Este proceso finaliza con la llamada inicial.

Colas: Definicin y operaciones con colas, ejemplos. Colas circulares, Doble cola y aplicaciones.

Definicin: Una cola, es una estructura en la cual se almacenan elementos (en orden de llegada), es decir que, se ingresan los elementos por la parte final de la estructura y se eliminan (o se sirven) por la parte del frente.

Como puede observarse, sta estructura cuenta con dos apuntadores, uno que apunta al ltimo elemento y otro que apunta hacia el primer elemeto (o el elemento del frente). Se debe tener en cuenta que, una cola, almacena los datos en ella, manteniendo cierto orden, ya que sus elementos se aaden por el final de la cola y se extraen o se eliminan por la parte de frente. El lector dispernsar el por que la insistencia de ello, pero cuando uno inicia este estudio, al momento de programar, se cunfe fcilmente, por que las sentencias de las funciones son muy parecidas a la de una pila, y en algunas ocaciones me pasaba que empezaba programando una cola, pero terminaba funcionando como pila.

Operaciones:

La figuara de arriba, muestra la forma de implementar una cola, como arreglo, en la que cada casilla, representa una estructura compuesta por el tipo de dato a guardar (o bien otra estructura). Las variables q.rear y q.front, se van modificando cada vez que aadimos o eliminamos datos de nuestra cola. Para determinar la cantidad de elementos en cualquier momento es: Cant=q.rear-q.front+1 Ahora vemos un ejemplo del funcionamiento de las colas, implementadas como arreglos: Supongamos que en una cola vamos a almacenar elementos de tipo carcter. Insert(&q, A);

q.rear=0, q.front=0 insert (&q, B)

q.rear=1 q.front=0 insert (&q, C);

q.rear=2 q.front=0 remove(&q);

q.rear=2

q.front=1 remove(&q);

q.rear=2 q.front=2 insert(&q, D); C D 01234 q.rear=3 q.front=2 insert(&q, E);

q.rear=4 q.front=2

Colas circulares: INSERTAR EN UNA COLA CIRCULAR Algoritmo que sirve para insertar un dato DATO en una cola Circular COLACIR con MAX elementos y los marcadores de FRENTE y FINAL. Insertacircular(COLACIR, MAX, FRENTE, FINAL, DATO) Inicio Si ((FINAL=MAX) Y (FRENTE=1)) o ((FINAL+1)= FRENTE) entonces Imprimir (Desbordamiento) /* Cola Llena */ Sino Si (FINAL = MAX) entonces

FINAL Sino FINAL Fin si

FINAL +1

COLACIR[FINAL]

DATO

Si (FRENTE = 0) entonces FRENTE Fin si Fin si Fin 1

ELIMINAR EN UNA COLA CIRCULAR Algoritmo que elimina el primer elemento de una cola circular COLACIR y lo almacena en DATO. FRENTE Y FINAL marcan el inicio y fin de la cola. La cola tiene un tamao de MAX elementos.

Elminacircular(COLACIR, MAX, FRENTE, FINAL, DATO) Inicio Si (FRENTE = 0) entonces /* verifica si la cola esta vaca */ Imprimir(Subdesbordamiento) Sino DATO COLACIR[FRENTE]

Si (FRENTE = FINAL) entonces /* solo hay un elemento */ FRENTE FINAL Sino Si (FRENTE = MAX) entonces FRENTE Sino FRENTE Fin si Fin si FRENTE +1 1 0 0

Fin si Fin

Doble Cola: Una cola doble es una estructuras en donde cada elemento puede ser insertado y recuperado por la parte del frente (cabeza) o por la parte de atrs (cola) de la lista. A diferencia de una cola sencilla, en donde solo se necesitan un mtodo para leer y otro para escribir componentes en la lista, en una doble cola debe haber dos mtodos para leer ( uno para leer por el frente y uno para leer por atrs ) y dos mtodos para escribir ( uno para escribir por el frente y uno para escribir por atrs ).

En el programa que se ver en seguida, se simula el comportamiento de una estructura de cola doble con base en un arreglo esttico. En dicho programa se declara e implementa la clase SDQueue con los siguientes mtodos: put_front(), poner un elemento en el frente de la cola put_back(), poner un elemento en la parte tracera de la cola get_front(), retirar un elemento de la parte frontal de la cola get_back(), retirar un elemento de la parte tracera de la cola empty(), size(), regresa 1 (TRUE) si la cola est vacia nmero de elementos en la cola

Doble cola en un arreglo esttico /*------------------------------------------------------------------+ + ejemplo de una cola doble (DQUEUE) basada en un arreglo est tico + ++ + Autor: Oscar E. Palacios + + email: oscarpalacios1@yahoo.com.mx + ++ + Manifiesto: + + Este programa puede distribuirse, copiarse y modificarse de +

+ forma libre. + +------------------------------------------------------------------*/ #include <iostream.h> #include <mem.h> // por memmove

// using namespace std; #define MAX_SIZE 256 #define t_error -1;

typedef int DATA_TYPE; // mximo nmero de elementos typedef int almacen[MAX_SIZE];

class SDQueue { // atributos int itemsize; // tamao de cada elemento int items; // nmero de elementos

int cola, cabeza; // punteros de lectura y escritura almacen alma; // el almacen o arreglo

public: // constructor SDQueue() : cola(0), cabeza(0), items(0), itemsize(sizeof(DATA_TYPE)) {}

// destructor ~SDQueue() {}

int empty() { return items == 0; }

int size() { return items; }

/* agregar componente en la parte tracera de la lista */ DATA_TYPE put_back(DATA_TYPE valor) { if (items == MAX_SIZE) return t_error;

alma[cola] = valor; items ++; cola ++; return valor; }

/* agregar componente en la parte delantera de la lista */ DATA_TYPE put_front(DATA_TYPE valor) { if (items == MAX_SIZE) return t_error; memmove((void *)&alma[cabeza+1], (void*)&alma[cabeza], items*itemsize); alma[cabeza] = valor; items ++; cola ++; return valor; }

/* retirar elemento de la parte frontal de la lista */ DATA_TYPE get_front() { DATA_TYPE d;

if ( empty() ) return t_error; items --; cola --; d = alma[cabeza]; memmove((void*)&alma[cabeza], (void*)&alma[cabeza+1], items*itemsize); return d; }

/* retirar elemento de la parte tracera de la lista */ DATA_TYPE get_back() {

DATA_TYPE d;

if ( empty() ) return t_error; items--; cola --; d = alma[cola]; return d; }

}; // fin de la clase SDQueue

/* punto de prueba */ int main() { SDQueue s; DATA_TYPE d;

for (d='A'; d<='Z'; d++) s.put_back(d);

while ( ! s.empty() ) cout << (char)s.get_front() << " ";

cout << "\nPara terminar presione <Enter>..."; cin.get(); return 0; } Una cola doblemente encadenada es una estructuras en donde cada elemento puede ser insertado y recuperado por la parte del frente (cabeza) o por la parte de atras (cola) de la lista. A diferencia de una cola sencilla, en donde solo se necesita un puntero a un siguiente elemento, la estructura del nodo para una doble cola debe poseer un puntero a un posible siguiente elemento y un puntero a otro posible anterior elemento. Por ejemplo, para crear una estructura de nodo con doble enlace para coleccionar nmeros enteros podemos usar la sintaxis:

struct nodo { int data; nodo *next, *prev; }; Grficamente podemos imaginar la estructura anterior como: +------+------+------+ <--| prev | data | next |--> +------+------+------+

Aplicaciones: Colas implementadas con Memoria Dinmica Para hacer uso de las colas, debemos declarar el nodo y los apuntadores de la cola, as: typedef struct _nodo { int dato; struct _nodo *siguiente; } tipoNodo; typedef tipoNodo *pNodo; typedef tipoNodo *Cola; Donde, es evidente que, tipoNodo es el tipo de los nodos que compondrn la cola. pNodo es el tipo para declarar punteros a un nodo. Cola es el tipo para declarar colas

Las operaciones, siguen siendo las mismas: Aadir Eliminar Listas: Definicin, tipos y operaciones con listas, Aplicaciones, Representacion. Ejemplo.

Definicin: Es un conjunto ordenado de elementos homogneos, en la que no hay restricciones de acceso, la introduccin y borrado de elementos puede realizarse en cualquier posicin deborrado de elementos puede realizarse en cualquier posicin de la misma.

Tipos y operaciones con listas.

Listas enlazadas lineales Listas simples enlazadas La lista enlazada bsica es la lista enlazada simple la cual tiene un enlace por nodo. Este enlace apunta al siguiente nodo (o indica que tiene la direccin en memoria del siguiente nodo) en la lista, o al valor NULL o a la lista vaca, si es el ltimo nodo. Listas doblemente enlazadas Un tipo de lista enlazada ms sofisticado es la lista doblemente enlazada o lista enlazadas de dos vas. Cada nodo tiene dos enlaces: uno apunta al nodo anterior, o apunta al valor NULL si es el primer nodo; y otro que apunta al nodo siguiente, o apunta al valorNULL si es el ltimo nodo. En algn lenguaje de muy bajo nivel, XOR-Linking ofrece una va para implementar listas doblemente enlazadas, usando una sola palabra para ambos enlaces, aunque esta tcnica no se suele utilizar. Listas enlazadas circulares En una lista enlazada circular, el primer y el ltimo nodo estn unidos juntos. Esto se puede hacer tanto para listas enlazadas simples como para las doblemente enlazadas. Para recorrer una lista enlazada circular podemos empezar por cualquier nodo y seguir la lista en cualquier direccin hasta que se regrese hasta el nodo original. Desde otro

punto de vista, las listas enlazadas circulares pueden ser vistas como listas sin comienzo ni fin. Este tipo de listas es el ms usado para dirigir buffers para ingerir datos, y para visitar todos los nodos de una lista a partir de uno dado.

Una lista enlazada circular que contiene tres valores enteros

Listas enlazadas circulares simples Cada nodo tiene un enlace, similar al de las listas enlazadas simples, excepto que el siguiente nodo del ltimo apunta al primero. Como en una lista enlazada simple, los nuevos nodos pueden ser solo eficientemente insertados despus de uno que ya tengamos referenciado. Por esta razn, es usual quedarse con una referencia solamente al ltimo elemento en una lista enlazada circular simple, esto nos permite rpidas inserciones al principio, y tambin permite accesos al primer nodo desde el puntero del ltimo nodo. 1 Listas enlazadas doblemente circulares En una lista enlazada doblemente circular, cada nodo tiene dos enlaces, similares a los de la lista doblemente enlazada, excepto que el enlace anterior del primer nodo apunta al ltimo y el enlace siguiente del ltimo nodo, apunta al primero. Como en una lista doblemente enlazada, las inserciones y eliminaciones pueden ser hechas desde cualquier punto con acceso a algn nodo cercano. Aunque estructuralmente una lista circular doblemente enlazada no tiene ni principio ni fin, un puntero de acceso externo puede establecer el nodo apuntado que est en la cabeza o al nodo cola, y as mantener el orden tan bien como en una lista doblemente enlazada. List Comprehension La notacin List Comprehension es similar a la utilizada en matemticas para construir conjuntos, y puede ser muy til a la hora de construir ciertos tipos de listas. La sintaxis es como sigue: [expresion|calificador,calificador,...]

Con esta expresin se genera una lista donde los elementos son de la forma de expresin y cumplen las condiciones expresadas en los calificadores. La expresin puede ser cualquier expresin vlida y los calificadores pueden ser de 3 tipos: generadores, filtros y definiciones locales.

Generadores: Generan un nmero de elementos que se pueden usar en la expresin de la lista. Su sintaxis es: patron<-lista. Los generadores que aparecen ms a la izquierda varan cuando se han generado todas las posibilidades de los de la derecha. Los generadores pueden depender de las variables introducidas en generadores anteriores

Filtros: Son expresiones booleanas que eliminan elementos que se otra forma se incluiran en la lista. En la lista resultante, slo estn los elementos que satisfacen la expresin del filtro.

Definiciones locales: Se pueden definir variables locales dentro de la lista.

Veamos algunos ejemplos de construccin de listas: [n|n<-[1..5]] [n*n|n<-[1..5]] [1,2,3,4,5] [1,4,9,16,25] [2,4] [(2,4),(3,9)]

[n|n<-[1..5], par n]

[(n, n*n)|n<-[1..3], n<n*n] [n*n|n=2] [1|n<-[1..5]] [4] [1,1,1,1,1]

[(i,j)|i<-[1..2], j<-[1..2]]

[(1,1), (1,2), (2,1), (2,2)]

Ejemplos Ejemplos que ilustran la utilizacin de listas. Funcin que me dice si un nmero es o no primo. divisores Int->[Int] divisores n=[d|d<-[1..n], n mod d==0] primo Int->Bool primo n=(divisores n==[1,n]) Funcin que devuelve el nsimo elemento de una lista. enesimo Int->[Int]->Int enesimo 1 (c:cola)=c enesimo n (c:cola)=enesimo(n-1) cola Funcin que invierte una lista. invertir [Int]->[Int] invertir []=[] invertir (c:cola)=invertir cola++[c]

Conceptos Avanzados: Excepciones, Multith Reading

de los aos 1990. Esto permiti que reemergiera a una posicin destacada el concepto del computacin de rendimiento a partir del ms especializado campo del procesamiento transaccional:

Aunque es muy difcil acelerar un solo hilo o un solo programa, la mayora de los sistemas de computadores son realmente multitarea entre mltiples hilos o programas.

Las tcnicas que permitiran acelerar el rendimiento total del procesamiento del sistema en todas las tareas (tasks) daran como resultado un aumento significativo del rendimiento. Las dos principales tcnicas para computacin de rendimiento son el multiproceso y el multihilo.

Una cierta crtica del multihilo incluye:

Los mltiples hilos pueden interferir uno con el otro al compartir recursos de hardware como cachs o Translation Lookaside Buffer (TLB).

Los tiempos de ejecucin de un solo hilo no son mejorados, sino por el contrario, pueden ser degradados.

El soporte de hardware para multihilo es ms visible al software que el multiprocesamiento, por lo tanto requiriendo ms cambios tanto a las aplicaciones como el sistema operativo.

Las tcnicas de hardware usadas para soportar multihilo a menudo paralelizan las tcnicas de software usadas para la multitarea de los programas de computadora.

Fundamentos de la programacin avanzada orientada a objeto : utilizacin de estructuras dinmicas de datos y operaciones de entrada y salida
La programacin orientada a objetos es la expresin de uno de los ms avanzados paradigmas en el campo de la programacin, y es, al mismo tiempo, el resultado de la evolucin experimentada por los paradigmas anteriores.

A diferencia de otros paradigmas de programacin, que intentan, al abordar un problema, representarlo o modelarlo empleando entidades cercanas a la

computadora (arreglos, subrutinas, mdulos) la programacin orientada a objetos se propone emplear entidades lo ms cercanas posibles a la realidad.

La programacin orientada a objetos tiene como conceptos fundamentales los conceptos de objeto y clase.

Un objeto es un ente que posee sus caractersticas propias (propiedades) y un conjunto de acciones que es capaz de realizar (mtodos).

Una clase es un ente abstracto que permite declarar las propiedades y los mtodos de objetos similares.

Un lenguaje de programacin orientado a objetos debe permitir al programador realizar definiciones de clases, y construir objetos a partir de esas clases.

Para resolver un problema bajo el paradigma de la programacin orientada a objetos basta con determinar y caracterizar los diferentes objetos que intervienen en el problema, definir sus propiedades y mtodos y ponerlos a interactuar entre s.

Ejemplo:

Supongamos que se desea disear una aplicacin para controlar a todo el personal que estudia o trabaja en el Instituto Superior Pedaggico conociendo

la informacin correspondiente a cada uno de ellos.

Trabajadores Docentes Nombre Direccin Nmero de Identidad Sexo Fecha de Ingreso Cargo Salario Departamento Asignatura

Trabajadores de Servicio Estudiantes Nombre Direccin Nmero de Identidad Sexo Fecha de Ingreso Cargo Salario rea Nombre Direccin Nmero de Identidad Sexo Ao Especialidad

Tabla #1

Inicialmente podramos pensar en declarar tres clases : TDocente, TServicio y Estudiante; pero si analizamos la informacin observamos que hay propiedades que se repiten en las tres clases como son: Nombre, Direccin, Nmero

de Identidad y Sexo por lo que se pudiera declarar una clase Persona que agrupe estas propiedades comunes y as no tener que repetirlas en cada una de las clases por lo que tendramos ahora cuatro clases:

Pero an quedan, en las clase TDocente y TServicio propiedades comunes por lo que se pudiera declarar una clase Trabajador con las propiedades Fecha Ingreso, cargo y Salario quedando finalmente cinco clases:

De acuerdo a las clase que hemos concebido podemos decir que un Estudiante es una Persona que tiene un ao y una especialidad; un Trabajador es una Persona que tiene una fecha de ingreso, un cargo y un salario; un Trabajador docente es un Trabajador que tiene un departamento y una asignatura y un Trabajador de servicio es un Trabajador que tiene rea.

Los Estudiantes y los Trabajadores forman subconjuntos de las Personas. La clase Persona es la Clase Base de las clases Estudiante y Trabajador por lo que estas clases heredan las propiedades y los mtodos de la clase Persona.

De manera similar los Trabajadores Docentes y los Trabajadores de Servicio son subconjuntos de los Trabajadores por lo que la clase Trabajador es Clase Base de las clases TDocente y TServicio y por tanto heredan las propiedades y los mtodos de la clase Trabajador.

Luego las cinco clases seran:

Clase Persona Propiedades: Nombre Direccin Nmero de Identidad Sexo Mtodos: Entrar Direccin Visualizar Nombre Visualizar Direccin Visualizar Nmero Identidad Visualizar Sexo

Tabla #2

Puedes constatar que no hemos definido mtodos para Entrar nombre, Entrar nmero de identidad, ni Entrar sexo porque no tienen sentido; la persona no puede cambiar su nombre, nmero de carn de identidad, ni sexo ella misma.

Nuestra persona tiene la posibilidad de cambiar de direccin y de visualizar su nombre, direccin, nmero de identidad y sexo. Clase Trabajador Propiedades y mtodos de la clase Persona Propiedades: Fecha de Ingreso Cargo Salario Mtodos: Entrar Cargo Entrar Salario Visualizar Fecha de Ingreso Visualizar Cargo Visualizar Salario

Tabla #3

Nuestro trabajador tiene la posibilidad de cambiar de cargo y de salario y de visualizar su cargo, salario y fecha de ingreso; pero tambin puede cambiar su direccin y visualizar su nombre, direccin, nmero de carn de identidad y sexo porque es a la vez un trabajador y una persona.

Clase Estudiante Propiedades y mtodos de la clase Persona Propiedades: Ao Especialidad Mtodos: Entrar Ao Visualizar Ao Visualizar Especialidad

Tabla #4

Nuestro estudiante tiene la posibilidad de cambiar de ao y de visualizar el ao que cursa y su especialidad; pero tambin puede cambiar su direccin y visualizar se nombre, direccin, nmero de carn de identidad y sexo porque es a la vez un estudiante y una persona.

Clase TDocente Propiedades y mtodos de la clase Trabajador Propiedades: Departamento Asignatura Mtodos: Entrar Departamento Entrar Asignatura Visualizar Departamento Visualizar Asignatura

Tabla #5

Nuestro trabajador docente tiene la posibilidad de cambiar de departamento y de asignatura y de visualizar el departamento y la asignatura a la que pertenece; pero tambin puede cambiar su direccin, cargo y salario y visualizar su nombre, direccin, nmero de carn de identidad, sexo y fecha de ingreso porque es a la vez un trabajador docente y un trabajador que es a su vez una persona.

Clase TServicio Propiedades y mtodos de la clase Trabajador Propiedades: rea Mtodos: Entrar rea Visualizar rea

Conclusin.
Para entender cmo funciona el paradigma de la programacin orientada a objetos es necesario ver un programa como una coleccin de objetos que interactan entre s envindose mensajes y cambiando su estado durante la ejecucin. Resolver un problema bajo el paradigma de la programacin orientada a objetos implica determinar y caracterizar los diferentes objetos que intervienen en el problema, definir sus propiedades y mtodos y ponerlos a interactuar.

Bibliografa.
http://www.monografias.com/trabajos28/programacion-objetos/programacionobjetos.shtml#ixzz2Vz6Rnkrd

https://es.wikipedia.org/wiki/Lista_(inform%C3%A1tica)#Tipos_de_listas_enlazadas

http://www.tonahtiu.com/notas/estructuras/pila_concepto.htm

http://isbeliramirez.blogspot.com/2012/02/pilas-y-colas.html

http://espanol.answers.yahoo.com/question/index?qid=20081111103123AANJzfB

http://www.infor.uva.es/~mserrano/EDI/cap1.pdf

http://www.monografias.com/trabajos38/manual-programacion/manual-programacionc6.shtml