Está en la página 1de 71

LISTA DOBLEMENTE

ENLAZADA.
(LDE)
GRUPO: 401
PROFESOR: ING ROGELIO VÁZQUEZ HERNÁNDEZ
AGREGAR NODO AL FINAL.
• Algoritmo
1. Crear nuevo nodo
2. Asignar dato al nodo
3. Verificar que la lista está vacía
4. Si está vacía
4.1 Establecer el nuevo nodo como nodo inicial

5. No ésta vacía
5.1 Buscamos el ultimo nodo
5.2 El apuntador sig. del ultimo nodo apunta al nuevo nodo
5.3 El apuntador ant. del nuevo nodo apunte al último nodo

6. Fin
• Pseudocodigo:
1. Procedimiento agregarAlFinal(dato)
2. Nodo nuevo nodo
3. nuevoNodo.dato ← dato
4. Si lista_vacia () entonces
1. nodoInicial ← nuevo nodo;
5. En caso contrario
1. ultimoNodo ← nodoInicial
6. mientras ultimoNodo.ap <> nulo entonces
1. ultimoNodo ← ultimoNodo.ap
2. fin_mientras
7. ultimoNodo.apSig ← nuevoNodo
8. nuevoNodo.apAnt ← ultimoNodo
9. fin_si
10. fin_procedimiento
• Código en
JAVA:
AGREGAR NODO AL INICIO.
Algoritmo:
1. Crear nuevo nodo
2. Asignar dato al nuevo nodo
3. Verificar que la lista está vacía
4. Si esta vacía
4.1 establecer nuevo nodo como nodo inicial

5. no está vacía
5.1 el apuntador Ant. Del nodo inicial apunta al nuevo nodo
5.2 el apuntador Sig. Del nuevo nodo apunta al nodo inicial
5.3 el nuevo nodo se establece como nodo inicial.

6. Fin.
• Pseudocodigo:
1. Procedimiento agregarAlInicio (dato);
2. Nodo nuevoNodo;
3. NuevoNodo.dato(dato);
4. Si lista_vacia entonces
4.1 nodoInicial ← nuevoNodo

5. En caso contrario
5.1 nodoInicial.apAnt ← nuevoNodo
5.2 NuevoNodo.apSig ← nodoInicial
5.3 nodoInicial ← nuevoNodo

6. Fin_si
7. Fin_procedimiento
• Código en
JAVA:
AGREGAR ANTES DE…
• Algoritmo:
1. Verificar que la lista no esté vacía
2. Si la lista no está vacía
1. buscar el nodo de referencia
2. No encontró el nodo de referencia
1. devuelve falso
3. sí encontró al nodo de referencia
1. verificar que el nodo de referencia es el primero
2. sí es el primero
1. llamar agregar al inicio
3. si no es el primero
1. crear nuevo nodo y asignar el dato
2. apuntador Sig. Del nuevo nodo toma el valor del nodo de referencia
3. apuntador Sig. Del nodo anterior de nodo de referencia apunta al nuevo nodo
4. apuntador Ant. De nuevo nodo apunta al nodo anterior
5. apuntador Ant. Del nodo de referencia apunta al nuevo nodo

3. sí lista vacía
1. devolver falso

4. Fin.
• Pseudocodigo 7. En caso contrario
1. Procedimiento agregarAntesDe (dato, 1. Nodo nuevoNodo
datoReferencia) { 2. nuevoNodo.dato ← dato
3. nuevoNodo.ApSig ← nodoReferencia
2. Si no lista_vacia entonces
4. nodoAnterior ←
1. Nodo nodoReferencia ← buscarNodo
nodoReferencia.apAnt
(datoReferencia)
5. nodoAnterior.apSig ← nuevoNodo
3. Si nodoReferencia ← vacio entonces 6. nuevoNodo.ApAnt ← nodoAnterior
4. Retorna falso 7. nodoReferencia.ApAnt ← nuevoNodo
5. En caso contrario 8. fin_si
6. Si nodoReferencia = nodoInicial 1. retorna verdadero
entonces 9. fin_si
1. Llamar a agregarAlInicio(dato) 1. en caso contrario
1. retorna falso

10. fin_si
11. fin_procedimiento
• Código en
JAVA:
AGREGAR DESPUÉS DE…
• Algoritmo: 1. Si no es el ultimo
1. Crear nuevo nodo y asignar
1. Verificar que la lista no está dato
vacía 2. El apuntador Sig. del nuevo
nodo toma el valor del
2. Si lista no está vacía apuntador sig. del nodo de
referencia
1. Buscar el nodo de referencia
3. El nodo siguiente de nodo de
2. No encontró el nodo de referencia en su apuntador Ant.
referencia apunta al nuevo nodo
1. Devuelve falso 4. El apuntador Ant del nuevo
nodo apunta al nodo de
3. Si encontró el nodo de referencia
referencia 5. El apuntador Sig. del nodo de
1. Verificar si el nodo de referencia referencia apunta al nuevo nodo
es el ultimo
1. Si lista vacía
2. Si es el ultimo
1. Devuelve falso
1. Llamar agregar al final
2. Fin
• Pseudocodigo: • En caso contrario
• Procedimiento agregarDespuesDe • Nodo nuevoNodo.dato  dato
• si no lista_vacia entonces • nuevoNodo.ApSig 
• Nodo nodoReferencia  nodoReferencia.ApSig
buscarNodo(datoReferencia) • nodoSig = nodoReferencia.ApSig
• Si nodoReferencia = vacio entonces • nodoSig.ApAnt nuevoNodo
• Retorna falso • nuevoNodo.apAnt  nodoReferencia
• En caso contrario • nodoReferencia.apSig  nuevoNodo
• Si nodoReferencia.ap = vacio • fin_si
• Llamar • retornar verdadero
agregarAlFinal(dato) • En caso contrario
• Retornar falso
• Fin_Procedimiento.
• Código en
JAVA:
ELIMINAR AL INICIO.
Algoritmo:

• Verificar si la lista no esté vacía


• Si lista no está vacío
• Verificar si el nodo inicial es el único
• Si es el único
• El nodo inicial tomara el valor a vacío
• Si no es el único
• El nodo temporal toma el valor del nodo inicial
• El nodo inicial tomara el valor del apuntador Sig. del nodo inicial
• El nodo temporal en su apuntador Sig. toma el valor de vacío
• El nodo temporal en su apuntador Ant tomar el valor de vacío

• Si lista está vacía


• Devolver falso

• Fin
Pseudocodigo:
• procedimiento eliminarAlInicio()
• si no lista_vacia entonces
• si nodoInicial.apSig = vacio entonces
• nodoInicial  vacio
• En caso contrario
• NodoD nodoTemporal  nodoInicial
• nodoInicial  nodoInicial.apSig
• nodoTemporal.apSig()  vacio
• nodoTemporal.apAnt()  vacio
• Fin_si
• Retornamos verdadero
• En caso contrario
• Retornamos falso
• Fin_si
• Fin_procedimiento
• Código en
JAVA:
ELIMINAR AL FINAL.
Algoritmo:
• Verificar que la lista no está vacía
• Si lista no está vacía
• Verificar si el apuntador sig. de nodo inicial no apunte a vació
• Si apunta al vacío
• El nodo inicial toma el valor de vacío
• Si no apunta al vacío
• Buscar el ultimo nodo
• El apuntador sig. del nodo anterior de nodo de referencia apunta al vacío
• El apuntador Ant. del ultimo nodo apunta al vacío

• Si lista vacía
• Devuelve falso

• Fin
Pseudocodigo • En caso contrario
• Procedimiento eliminarAlFinal() • retorna falso
• si no lista_vacia • Fin_si
• Si nodoInicial.apSig = vacio entonces • Fin_procedimiento
• nodoInicial←vacio

• en caso contrario
• Mientras ultimoNodo.apSig <> vacio
hacer
• UltimoNodo ← ultimoNodo.ap
• Fin_mientras
• NodoAnterior = ultimoNodo.apAnt
• nodoAnterior.apSig←vacio
• ultimoNodo.apvacio
• Retorna verdadero
• Fin_si
• Retorna falso
• Código en
JAVA:
ELIMINAR NODO CON “X”
INFORMACIÓN.
• Si es el último nodo
Algoritmo:
• Llamar eliminar al final
• Verificar que la lista no esté • Si no es el último nodo
vacía • El nodo anterior tomara el valor
del apuntador Ant. del nodo
eliminar
• Si lista no está vacía • El nodo siguiente tomara el
• Buscar el nodo a eliminar valor del apuntador sig. del
nodo eliminar
• No encontré el nodo eliminar • El apuntador Sig. del nodo
• Devuelve falso anterior apunta al nodo
siguiente
• Si encontré el nodo eliminar • El apuntador Ant. del nodo
• Verificar si el nodo eliminar es el siguiente apunta al nodo
anterior
nodo inicial
• El apuntador Sig del nodo
• Si es el nodo inicial eliminar apunta a vacío
• Llamar eliminar al inicio • El apuntador Ant. del nodo
eliminar apunta a vacío
• Si no es el nodo inicial
• Verificar el nodo eliminar es el • Si lista está vacía
último nodo
• Devolver falso
• fin
Pseudocodigo • en caso contrario
• Procedimiento eliminarNodoX (datoEliminar) • NodoD nodoAnterior ←
nodoEliminar.apAnt
• Si lista no está vacia entonces
• NodoD nodoSiguiente ←
• NodoD nodoEliminar ← buscarNodo (datoReferencia)
nodoEliminar.apSig
• sí nodo eliminar es igual a vacio entonces
• nodoAnterior.apSig ← nodoSiguiente
• retorna falso
• nodoSiguiente.apAnt ← nodoAnterior
• en caso contrario
• nodoEliminar.apSig ← vacio
• sí nodo eliminar = nodo inicial entonces
• nodoEliminar.apAnt ← vacio
• llamar a eliminarAlInicio
• Fin_si
• en caso contrario
• Retorna verdadero
• sí nodo eliminar.apSig = vacio entonces
• en caso contrario
• llamar eliminarAlFinal
• retorna falso
• Fin_si
• Fin_procedimiento
• Código en
JAVA:
ELIMINAR ANTES DE…
Algoritmo: 3. Si no es el primero
1. Verificar si el apuntador Ant. del nodo
1. Verificar que la lista no es vacía de referencia está apuntando a nodo
inicial
2. Si lista no está vacía 2. Si apunta a nodo inicial
1. Buscar el nodo de referencia 1. Llamar eliminar al inicio

2. No encontré el nodo de referencia 3. Si no apunta a nodo inicial


1. el nodo eliminar tomara el valor que
1. Devuelve falso tiene el apuntador Ant. del nodo de
referencia
3. Si encontró el nodo de referencia
2. el nodo anterior tomara el valor que
1. Verificar si el nodo de referencia es el tiene el apuntador Ant. del nodo
primero eliminar
3. el apuntador Ant del nodo de referencia
2. Si es el primero apuntara al nodo anterior
1. Devolver falso 4. el apuntador sig. del nodo anterior
apuntara al nodo de referencia
5. el nodo eliminar tomara el valor de
vacío

2. sí lista está vacía


1. devolver falso
3. fin
1. procedimiento eliminarAntesDe 10. En caso contrario
(datoReferencia)
11. NodoD NodoEliminar ←
2. si no listaVacia entonces nodoReferencia.apAnt
1. NodoD nodoReferencia ← buscarNodo 12. NodoD nodoAnterior ← nodoEliminar.apAnt
(datoReferencia)
13. nodoReferencia.apAnt() ← nodoAnterior
3. Si nodoReferencia = vacio entonces
14. nodoAnterior.apSig() ← nodoReferencia
4. retornamos falso
15. nodoEliminar.apAnt ← vacío
5. En caso contrario
16. nodoEliminar.apSig ← vacio
6. Si nodoReferencia = nodoInicial entonces
17. fin_si
7. retornamos falso
18. retornar verdadero
8. En caso contrario
19. fin_si
9. Si nodoReferencia.apAnt ← nodoInicial
1. Llamar eliminarAlInicio 20. En caso contrario
21. retornar falso
22. Fin_procedimiento
• Código en
JAVA:
ELIMINAR DESPUÉS
DE…
Algoritmo:
4. Si es el ultimo
1. Verificar que la lista no está vacía 1. Llamar eliminar al final
2. Si no está vacía 5. Si no es ultimo
1. Buscar nodo de referencia 1. El apuntador sig. del nodo de
referencia apuntara al nodo
2. No encontré el nodo de referencia siguiente
1. Devuelve falso 2. El apuntador Ant. del nodo
siguiente apuntara al nodo de
3. Si encontré el nodo de referencia referencia
1. Verificamos que el nodo de 3. El apuntador Sig del nodo
referencia no sea el ultimo eliminar apunta a vacío
2. Si es el ultimo 4. El apuntador Ant. del nodo
1. Devuelve falso eliminar apunta a vacío

3. Si no es el ultimo 3. Si lista está vacía


1. Nodo eliminar tomara el valor del
apuntador sig. del nodo de 1. Devolver falso
referencia
2. El nodo siguiente tomara el valor 4. Fin
del apuntador siguiente del nodo
eliminar
3. Verificar que el nodo eliminar no
sea el ultimo
• Pseudocodigo 14. En caso contrario
1. Procedimiento eliminarDespuesDe 15. nodoReferencia.apSig() ← nodoSiguiente
(datoReferencia)
16. nodoSiguiente.apAnt() ← nodoReferencia
2. Si no lista_vacia entonces
17. nodoEliminar.apSig() ← vacio
3. NodoD nodoReferencia ←
18. nodoEliminar.apAnt() ← vacio
buscarNodo(datoReferencia)
19 Fin_si
4. Si nodoReferencia = vacio entonces
20 Retorna verdadero
5. Retornamos falso
21 En caso contrario
6. En caso contrario
22. Retorna falso
7. Si nodoReferencia.apSig = vacio entonces
23. Fin_procedimiento
8. Retornamos falso
9. En caso contrario
10. NodoD nodoEliminar ←
nodoReferencia.apSig
11. NodoD nodoSiguiente ←
nodoEliminar.apSig
12. Si nodoEliminar = vacio entonces
13. Llamar eliminar_al_final
• Código en
JAVA:
LISTA VACÍA.
• Algoritmo:
1.Verificar que el nodo inicial no este vacío
2.Si no está vacío
1.devuelve verdadero
3.Si está vacío
1.devuelve falso
4.Fin
• Pseudocodigo
1.Procedimiento listaVacia
2.Si nodoInicial<> vacio entonces
1. Retorna falso
3.En caso contrario
1. Retorna verdadero
4. Fin
• Código en
JAVA:
BUSCAR NODO.
• Algoritmo Buscar nodo

1. Obtenemos el nodo a buscar


2. Apuntamos el nodo temporal al nodo inicial
3. Mientras el nodo a buscar sea diferente del nodo temporal
1. Hacer que nodo temporal sea igual al nodo que referencia su apuntador sig.

4. Si nodo temporal es vacío terminar la búsqueda


1. Terminar la búsqueda

5. Encuentra nodo a buscar


1. Devuelve el nodo temporal

6. Fin
• Pseudocodigo
1. Procedimiento buscarNodo(datoReferencia)
2. nodo nodoBusqueda
3. nodoBusqueda.dato ← datoReferencia
4. nodo nodoTemporal ← nodoInicial
5. mientras no igual (nodoBusqueda.nodoTemporal) hacer
6. nodoTemporal ← nodoTemporal.apSig
7. Si nodoTemporal = vacio entonces
8. Rompe ciclo
9. Fin_si
10. fin_mientras
11. retorna nodoTemporal
12. fin_procedimiento
• Código en
JAVA:
RECORRE ADELANTE.
• Algoritmo:

1. Verificar que lista no este vacia


2. No esta vacia
3. Nodo actual tomara valor de nodo inicial
4. Obtener todos los datos de los nodos que existen
en la lista
5. Devolver datos obtenidos
6. Si esta vacia
7. Devolver no existe nodo
• Pseudocodigo

1. Procedimiento recorrer_adelante ()
1. Si no listaVacia () entonces
1. nodoActual  nodoInicial
2. mientras nodoActual <> vacio hacer
1. contenido  contenido + texto (nodoActual)
2. nodoActual  nodoActual.apSig()
3. fin_mientras
4. retornamos contenido
2. en caso contrario
1. retornar “no existen nodos”
3. fin si

2. fin_procedimiento
• Código en
JAVA:
RECORRE ATRÁS.
• Algoritmo Recorrer atrás

1. Verificar que lista no este vacia


2. No esta vacia
3. Nodo actual tomara valor de nodo final
4. Obtener todos los datos de los nodos que existen
en la lista
5. Devolver datos obtenidos
6. Si esta vacia
7. Devolver no existe nodo
• Pseudocodigo

1. Procedimiento recorrer_atras ()
1. Si no listaVacia () entonces
1. nodoActual  nodoInicial
2. mientras nodoActual <> vacio hacer
1. contenido  texto(nodoActual) + contenido
2. nodoActual  nodoActual.apSig
3. fin_mientras
4. retornamos contenido
2. en caso contrario
1. retornar “no existen nodos”
3. fin_si

2. fin_procedimiento
• Código en
JAVA:
DIAGRAMA DE CLASES DEL
PROYECTO LDE.
CLASE MENÚ.
CLASE EJECUTABLE
DISEÑO DEL MENÚ.