PUNTEROS. Los punteros son de amplia utilización en programación y muchos lenguajes permiten la manipulación directa o indirecta de los mismos. Su razón de ser, reside en manejar datos alojados en la zona de memoria dinámica, bien sean datos elementales u objetos pertenecientes a una clase. Un puntero o apuntador es una variable que referencia una región de memoria; en otras palabras es una variable cuyo valor es una dirección de memoria. Si se tiene una variable p de tipo puntero que contiene una dirección de memoria en la que se encuentra almacenado un valor v se dice que p apunta a v. El programador utilizará punteros para guardar datos en memoria en muchas ocasiones. Trabajar con punteros implica la no manipulación de los datos en sí, sino manejar las direcciones de memoria en la cuales estos residen. LISTAS

NODO En programación, concretamente en estructuras de datos, un nodo es uno de los elementos de una lista enlazada, de un árbol o de un grafo. Cada nodo será una estructura o registro que dispondrá de varios campos, y al menos uno de esos campos será un puntero o referencia a otro nodo, de forma que, conocido un nodo, a partir de esa referencia, será posible en teoría tener acceso a otros nodos de la estructura. Los nodos son herramientas esenciales para la construcción de estructuras de datos dinámicas. LISTAS INFO INFORMACIÓN LIGA ENLACE SIGUIENTE NEXT Entero, lógico, real, carácter o texto, tipo registro, etc. Tipo apuntador o puntero Figura de Nodo Simple

LISTAS. La asignación de memoria es hecha durante la ejecución. Las listas enlazadas son estructuras de datos donde el acceso a un elemento no se hace mediante un índice sino mediante un puntero. La asignación de memoria es hecha durante la ejecución. Las listas enlazadas son estructuras dinámicas, queriendo decir esto que pueden crecer o encogerse durante la ejecución de un programa, utilizando así sólo la memoria que requiere. Una lista ligada es un mecanismo versátil conveniente para su uso en muchos tipos de bases de datos de propósito general. También puede reemplazar a los arreglos como base para otras estructuras de almacenamiento como pilas y colas. La ventaja más evidente de utilizar estructuras ligadas, es que permite optimizar el uso de la memoria, pues no desperdiciamos el espacio de localidades vacías. LISTAS

Una lista es una colección lineal de elementos llamados nodos donde el orden de los mismos se establece mediante punteros o referencias y existe un puntero/referencia especial llamado inicio (P, punta, cabeza) para localizar al primer elemento. La desventaja más grande de las estructuras ligadas es que deben ser recorridas desde su inicio para localizar un dato particular. Es decir, no hay forma de acceder al i-ésimo dato de la lista, como lo haríamos en un arreglo. Algunas listas más complejas son las listas doblemente ligadas o las listas circulares, por nombrar algunas. Desde el punto de vista de programación, una lista es una estructura de datos dinámica que contiene una colección de elementos homogéneos, con una relación lineal entre ellos. Una relación lineal significa que cada elemento (a excepción del primero) tiene un precedente y cada elemento (a excepción del último) tiene un sucesor. LISTAS

Las listas pueden ser: listas simples, listas dobles, listas simples circulares, listas dobles circulares entre otras. Listas simples enlazadas o simplemente ligadas. La lista enlazada básica es la lista enlazada simple la cual tiene un enlace por nodo. Este enlace apunta al siguiente nodo en la lista, o al valor NULL o a la lista vacía, si es el último nodo. Una lista enlazada simple contiene dos valores: el valor actual del nodo y un enlace al siguiente nodo. El último nodo de la lista enlazada tiene como liga un NULL, indicando que la lista termina en ese nodo. LISTAS null

Una lista enlazada se define por: El tipo de sus elementos o nodos Campo de información (datos) Campo enlace o liga (puntero) Un puntero de cabecera que permite acceder al primer elemento de la lista, utilizaremos la variable llamada CABEZA. Un medio para determinar el ultimo elemento de la lista: liga = null. Y nodo fin. Para acceder al campo dato de un registro p utilizaremos la siguiente notación puntero.dato o a su enlace puntero.siguiente Para liberar (borrar) un nodo de la memoria se hará de la siguiente manera: libere (p) LISTAS

NodoSimple - Dato: objeto - siguiente: NodoSimple - cabeza: NodoSimple - Final: NodoSimple + CrearInicio() + Imprimir() + CrearFinal() + InsertarCab() + EliminarCab() + InsertarUlt() + EliminarUlt() + InsertarAntes() + InsertarDespues() + Eliminar() …. ….. Clase NodoSimple //atributos propios de la clase dato es objeto cabeza, siguiente, Final, q, p es NodoSimple //constructor de inicializar Metodo NodoSimple() cabeza=null Final=null Fin del método nodo simple //constructor que recibe un parámetro y coloca en enlace o siguiente null Metodo NodoSimple(d es objeto) dato=d siguiente =null Fin del método nodo simple //constructor que recibe los dos parámetros para la parte de información del nodo y para la parte de enlace, liga o siguiente Método NodoSimple(d es objeto, liga es NodoSimple) dato=d siguiente=liga Fin del método nodo simple

LISTAS NODO DOBLE LIGA IZQUIERDA ANTERIOR LI LIGA DERECHA SIGUIENTE LD INFORMACIÓN PUEDE SER UN CAMPO O VARIOS CAMPOS DE DIFERENTE TIPO O DEL MISMO.

LISTAS MANEJO DE MEMORIA DINÁMIICA DE ESTE MODO FUNCIONAN LOS ENLACES O LIGAS, DE LAS POSICIONES DE MEMORIA, CON LA INFORMACION. EL ORDEN DE LOS NOMBRES EN LA LISTA SERIAN: JOSE, ANA, LOLO, PEDRO, PEPE, JULIO MAPEO IMAGINARIO DE LA MEMORIA A 11B 101 null B B 11A110 JOSE ANA PEDRO LOLO JULIO PEPE null

LISTAS NodoDoble - Dato: objeto - anterior: NodoDoble - siguiente: NodoDoble - cabeza: NodoDoble - fin: NodoDoble + CrearInicio() + Imprimir() + CrearFinal() + InsertarCab() + EliminarCab() + InsertarUlt() + EliminarUlt() + InsertarAntes() + InsertarDespues() + Eliminar() …. ….. Clase NodoDoble //atributos propios Dato es objeto anterior es NodoDoble siguiente es NodoDoble Cabeza es NodoDoble //constructores Metodo NodoDoble() Cabeza=fin=null Fin metodo NodoDoble Metodo NodoDoble(li es NodoDoble, d es objeto, ld es NodoDoble) Anterior=Li Dato=d Siguiente=Ld Fin metodo NodoDoble //variables globales d es objeto q,t,p es NodoDoble

LISTAS JOSE null 100 ANA CABEZA – INICIO - P Metodo Inicio(d es objeto) Si (VerificarLista()=verdadero) cabeza=nuevo NodoDoble(null,d,cabeza) sino cabeza=cabeza.anterior=nuevo NodoDoble (null,d,cabeza) fin si Fin inicio Método Crear por el inicio() resp es carácter Imprimir “Nombres para la lista s/n?” Leer resp Mientras (resp=“s”) Imprimir “digite Nombre para el inicio:” Leer d inicio(d) Imprimir “mas Nombres para la lista?” Leer resp Fin mientras Fin Crear por el inicio 111null Cabeza

LISTAS Metodo logico VerificarLista() Si (cabeza=null) entonces Imprimir “LISTA VACIA” retornar verdadero Si no retornar falso Fin si Fin verificar lista Metodo imprimirDesdeCabeza() Si (VerificarLista()=falso) entonces q=cabeza mientras (q<>null) imprimir “lista es:”+q.Dato q=q.siguiente fin mientras Fin si Fin imprimir JOSEnull CABEZA ANA LOLO PEDRO101 null 110 q JOSE q ANA q LOLO q PEDRO q=null

LISTAS Simples Dobles Básico Muy charro… PÁGINAS INTERESANTES, en la web.