INSTITUTO POLITÉCNICO

NACIONAL

ESCUELA SUPERIOR DE
INGENIERÍAMECÁNICA Y
ELÉCTRICA

UNIDAD ZACATENCO

TAREA 03: Algoritmos sobre

operaciones en listas doblemente enlazadas

Integrantes:
Olvera García Alberto

Profesor: Posadas Duran Juan Pablo Francisco

Grupo:3CV5
Fecha:25/Oct/2023
Insertar al inicio: Esta función recibe un valor y crea un nuevo nodo con ese valor
al principio de la lista. Para ello, se asigna el puntero ant del nuevo nodo a NULL y
el puntero sig a primero. Luego, se verifica si la lista está vacía o no. Si está vacía,
se asigna primero y ultimo al nuevo nodo. Si no está vacía, se asigna el puntero ant
de primero al nuevo nodo. Finalmente, se actualiza primero al nuevo nodo.

El código queda así:

// Insertar al inicio
void insertarInicio(Lista *lista, int valor) {
// Crear un nuevo nodo con el valor dado
Nodo *nuevo = new Nodo(valor);
// Asignar el puntero ant a NULL y el puntero sgt a primero
nuevo->ant = NULL;
nuevo->sig = lista->primero;
// Verificar si la lista está vacía o no
if (lista->primero == NULL) {
// Si está vacía, asignar primero y ultimo al nuevo nodo
lista->primero = nuevo;
lista->ultimo = nuevo;
} else {
// Si no está vacía, asignar el puntero ant de primero al nuevo nodo
lista->primero->ant = nuevo;
// Actualizar primero al nuevo nodo
lista->primero = nuevo;
}
}

Insertar al final: Esta función recibe un valor y crea un nuevo nodo con ese valor al
final de la lista. Para ello, se asigna el puntero ant del nuevo nodo a ultimo y el
puntero sig a NULL. Luego, se verifica si la lista está vacía o no. Si está vacía, se
asigna primero y ultimo al nuevo nodo. Si no está vacía, se asigna el puntero sig de
ultimo al nuevo nodo. Finalmente, se actualiza ultimo al nuevo nodo.

El código queda así:

// Insertar al final
void insertarFinal(Lista *lista, int valor) {
// Crear un nuevo nodo con el valor dado
Nodo *nuevo = new Nodo(valor);
// Asignar el puntero ant a ultimo y el puntero sig a NULL
nuevo->ant = lista->ultimo;
nuevo->sig = NULL;
// Verificar si la lista está vacía o no
if (lista->ultimo == NULL) {
 // Si está vacía, asignar primero y ultimo al nuevo nodo
lista->primero = nuevo;
lista->ultimo = nuevo;
} else {
// Si no está vacía, asignar el puntero sgt de ultimo al nuevo nodo
lista->ultimo->sig = nuevo;
// Actualizar ultimo al nuevo nodo
lista->ultimo = nuevo;
}
}

Eliminar al inicio: Esta función elimina el primer nodo de la lista y devuelve su valor.
Para ello, se verifica si la lista está vacía o no. Si está vacía, se devuelve “Lista
vacía”. Como indicador de error. Si no está vacía, se guarda el valor y el puntero sig
del primer nodo en variables auxiliares. Luego, se verifica si la lista tiene un solo
elemento o no. Si tiene un solo elemento, se asigna primero y ultimo a NULL. Si
tiene más de un elemento, se asigna el puntero ant de sig a NULL y se actualiza
primero a sig. Finalmente, se libera la memoria del primer nodo.

El código queda así:

// Eliminar al inicio
int eliminarInicio(Lista *lista) {
// Verificar si la lista está vacía o no
if (lista->primero == NULL) {
// Si cout “Lista Vacia”;
} else {
// Si no está vacía, guardar el valor y el puntero sig del primer nodo en variables auxiliares
int valor = lista->primero->valor;
Nodo *sig = lista->primero->sig;
// Verificar si la lista tiene un solo elemento o no
if (lista->primero == lista->ultimo) {
// Si tiene un solo elemento, asignar primero y ultimo a NULL
lista->primero = NULL;
lista->ultimo = NULL;
} else {
// Si tiene más de un elemento, asignar el puntero ant de sig a NULL y actualizar primero a
sig
sig->ant = NULL;
lista->primero = sig;
}
// Liberar la memoria delete lista->primero;
return valor;
}
Eliminar al final: Esta función elimina el último nodo de la lista y devuelve su valor.
Para ello, se verifica si la lista está vacía o no. Si está vacía, dice “Lista vacía” como
indicador de error. Si no está vacía, se guarda el valor y el puntero ant del último
nodo en variables auxiliares. Luego, se verifica si la lista tiene un solo elemento o
no. Si tiene un solo elemento, se asigna primero y ultimo a NULL. Si tiene más de
un elemento, se asigna el puntero sig de ant a NULL y se actualiza ultimo a ant.
Finalmente, se libera la memoria del último nodo.

// Eliminar al final
int eliminarFinal(Lista *lista) {
// Verificar si la lista está vacía o no
if (lista->ultimo == NULL) {
// Si está vacía, cout “Lista Vacía”
} else {
// Si no está vacía, guardar el valor y el puntero ant del último nodo en variables auxiliares
int valor = lista->ultimo->valor;
Nodo *ant = lista->ultimo->ant;
// Verificar si la lista tiene un solo elemento o no
if (lista->primero == lista->ultimo) {
// Si tiene un solo elemento, asignar primero y ultimo a NULL
lista->primero = NULL;
lista->ultimo = NULL;
} else {
// Si tiene más de un elemento, asignar el puntero sig de ant a NULL y actualizar ultimo a ant
ant->sig = NULL;
lista->ultimo = ant;
}
// Liberar la memoria del último nodo
delete lista->ultimo;
}
}

Eliminar al medio: Esta función recibe una posición y elimina el nodo que se
encuentra en esa posición de la lista. Para ello, se verifica si la posición es válida o
no. Si no es válida, se muestra “Lista Vacía” como indicador de error. Si es válida,
se recorre la lista hasta encontrar el nodo que corresponde a esa posición. Luego,
se guarda el valor y los punteros ant y sig del nodo en variables auxiliares. Después,
se verifica si el nodo es el primero o el último de la lista o no. Si es el primero, se
llama a la función eliminarInicio. Si es el último, se llama a la función eliminarFinal.
Si no es ninguno de los dos, se asignan los punteros ant de sig y sig de ant al nodo
anterior y al siguiente respectivamente. Finalmente, se libera la memoria del nodo.
El código queda así:

// Eliminar al medio
int eliminarMedio(Lista *lista, int pos) {
// Verificar si la posición es válida o no
if (pos < 1 || pos > lista->tam) {
// Si no es válida, cout “Lista Vacia”
} else {
// Si es válida, recorrer la lista hasta encontrar el nodo que corresponde a esa posición
Nodo *actual = lista->primero;
for (int i = 1; i < pos; i++) {
actual = actual->sig;
}
// Guardar el valor y los punteros ant y sig del nodo en variables auxiliares
int valor = actual->valor;
Nodo *ant = actual->ant;
Nodo *sig = actual->sig;
// Verificar si el nodo es el primero o el último de la lista o no
if (actual == lista->primero) {
// Si es el primero, llamar a la función eliminarInicio
eliminarInicio(lista);
} else if (actual == lista->ultimo) {
// Si es el último, llamar a la función eliminarFinal
eliminarFinal(lista);
} else {
// Si no es ninguno de los dos, asignar los punteros ant de sig y sig de ant al nodo anterior
y al siguiente respectivamente
sig->ant = ant;
ant->sig = sig;
// Liberar la memoria del nodo
delete actual;
}
// Devolver el valor
return valor;
}
}

Recorrer lista: Esta función permite acceder a los elementos de la lista desde el
principio hasta el final, o desde el final hasta el principio, según se desee. Para ello,
se necesita un puntero auxiliar que apunte al primer o al último nodo de la lista,
según el sentido del recorrido. Luego, se usa un bucle while para ir avanzando o
retrocediendo el puntero auxiliar por los nodos de la lista, mientras se muestra o se
procesa el valor de cada nodo.
El código queda así:

// Recorrer lista desde el principio hasta el final

void recorrerInicioFin(Lista *lista) {
// Crear un puntero auxiliar que apunte al primer nodo de la lista
Nodo *aux = lista->primero;
// Usar un bucle while para ir avanzando el puntero auxiliar por los nodos de la lista
while (aux != NULL) {
// Mostrar o procesar el valor del nodo actual
cout << aux->valor << " ";
// Avanzar el puntero auxiliar al siguiente nodo
aux = aux->sig;
}
// Mostrar un salto de línea al final del recorrido
cout << endl;
}

// Recorrer lista desde el final hasta el principio

void recorrerFinInicio(Lista *lista) {
// Crear un puntero auxiliar que apunte al último nodo de la lista
Nodo *aux = lista->ultimo;
// Usar un bucle while para ir retrocediendo el puntero auxiliar por los nodos de la lista
while (aux != NULL) {
// Mostrar o procesar el valor del nodo actual
cout << aux->valor << " ";
// Retroceder el puntero auxiliar al nodo anterior
aux = aux->ant;
}
// Mostrar un salto de línea al final del recorrido
cout << endl;
}

Actualizar listas: Esta función permite modificar el valor de uno o más nodos de la
lista, según algún criterio dado. Para ello, se necesita recorrer la lista con un puntero
auxiliar y verificar si el valor del nodo actual cumple con el criterio. Si es así, se
cambia el valor del nodo por uno nuevo.
El código queda así:

// Actualizar listas según algún criterio

void actualizarListas(Lista *lista, int criterio, int nuevo) {
// Crear un puntero auxiliar que apunte al primer nodo de la lista
Nodo *aux = lista->primero;
// Usar un bucle while para recorrer la lista con el puntero auxiliar
while (aux != NULL) {
// Verificar si el valor del nodo actual cumple con el criterio
if (aux->valor == criterio) {
// Si es así, cambiar el valor del nodo por uno nuevo
aux->valor = nuevo;
}
// Avanzar el puntero auxiliar al siguiente nodo
aux = aux->sig;
}
}
 Algoritmos sobre
operaciones en
listas doblemente
enlzadas

01
// Insertar al inicio
void insertarInicio(Lista *lista, int valor) {
// Crear un nuevo nodo con el valor dado
Nodo *nuevo = new Nodo(valor);
// Asignar el puntero ant a NULL y el puntero sgt a primero
nuevo->ant = NULL;
nuevo->sig = lista->primero;
// Verificar si la lista está vacía o no
if (lista->primero == NULL) {
// Si está vacía, asignar primero y ultimo al nuevo nodo
lista->primero = nuevo;
lista->ultimo = nuevo;
} else {
// Si no está vacía, asignar el puntero ant de primero al nuevo nodo
lista->primero->ant = nuevo;
// Actualizar primero al nuevo nodo
lista->primero = nuevo;
}
}

02
// Insertar al final
void insertarFinal(Lista *lista, int valor) {
// Crear un nuevo nodo con el valor dado
Nodo *nuevo = new Nodo(valor);
// Asignar el puntero ant a ultimo y el puntero sig a NULL
nuevo->ant = lista->ultimo;
nuevo->sig = NULL;
// Verificar si la lista está vacía o no
if (lista->ultimo == NULL) {
// Si está vacía, asignar primero y ultimo al nuevo nodo
lista->primero = nuevo;
lista->ultimo = nuevo;
} else {
// Si no está vacía, asignar el puntero sgt de ultimo al nuevo nodo
lista->ultimo->sig = nuevo;
// Actualizar ultimo al nuevo nodo
lista->ultimo = nuevo;
}
}

03 // Eliminar al inicio
int eliminarInicio(Lista *lista) {
// Verificar si la lista está vacía o no
if (lista->primero == NULL) {
// Si cout “Lista Vacia”;
} else {
// Si no está vacía, guardar el valor y el puntero sig del primer nodo en
variables auxiliares
int valor = lista->primero->valor;
Nodo *sig = lista->primero->sig;
// Verificar si la lista tiene un solo elemento o no
if (lista->primero == lista->ultimo) {
// Si tiene un solo elemento, asignar primero y ultimo a NULL
lista->primero = NULL;
lista->ultimo = NULL;
} else {
// Si tiene más de un elemento, asignar el puntero ant de sig a NULL y
actualizar primero a sig
sig->ant = NULL;
lista->primero = sig;
}
// Liberar la memoria delete lista->primero;
return valor;
}

04 // Eliminar al final
int eliminarFinal(Lista *lista) {
// Verificar si la lista está vacía o no
if (lista->ultimo == NULL) {
// Si está vacía, cout “Lista Vacía”
} else {
// Si no está vacía, guardar el valor y el puntero ant del último nodo en
variables auxiliares
int valor = lista->ultimo->valor;
Nodo *ant = lista->ultimo->ant;
// Verificar si la lista tiene un solo elemento o no
if (lista->primero == lista->ultimo) {
// Si tiene un solo elemento, asignar primero y ultimo a NULL
lista->primero = NULL;
lista->ultimo = NULL;
} else {
// Si tiene más de un elemento, asignar el puntero sig de ant a NULL y
actualizar ultimo a ant
ant->sig = NULL;
lista->ultimo = ant;
}
// Liberar la memoria del último nodo
delete lista->ultimo;
}
}
 Algoritmos sobre
operaciones en
listas doblemente
enlzadas

01
// Eliminar al medio
int eliminarMedio(Lista *lista, int pos) {
// Verificar si la posición es válida o no
if (pos < 1 || pos > lista->tam) {
// Si no es válida, cout “Lista Vacia”
} else {
// Si es válida, recorrer la lista hasta encontrar el nodo que corresponde a esa posición
Nodo *actual = lista->primero;
for (int i = 1; i < pos; i++) {
actual = actual->sig;
}
// Guardar el valor y los punteros ant y sig del nodo en variables auxiliares
int valor = actual->valor;
Nodo *ant = actual->ant;
Nodo *sig = actual->sig;
// Verificar si el nodo es el primero o el último de la lista o no
if (actual == lista->primero) {
// Si es el primero, llamar a la función eliminarInicio
eliminarInicio(lista);
} else if (actual == lista->ultimo) {
// Si es el último, llamar a la función eliminarFinal
eliminarFinal(lista);
} else {
// Si no es ninguno de los dos, asignar los punteros ant de sig y sig de ant al nodo anterior y al
siguiente respectivamente
sig->ant = ant;
ant->sig = sig;
// Liberar la memoria del nodo
delete actual;
}
// Devolver el valor
return valor;
}
}

02 // Recorrer lista desde el principio hasta el final

void recorrerInicioFin(Lista *lista) {
// Crear un puntero auxiliar que apunte al primer nodo de
la lista
Nodo *aux = lista->primero;
// Usar un bucle while para ir avanzando el puntero
auxiliar por los nodos de la lista
while (aux != NULL) {
// Mostrar o procesar el valor del nodo actual
cout << aux->valor << " ";
// Avanzar el puntero auxiliar al siguiente nodo
aux = aux->sig;
}
// Mostrar un salto de línea al final del recorrido
cout << endl;
}

03 // Recorrer lista desde el final hasta el principio

void recorrerFinInicio(Lista *lista) {
// Crear un puntero auxiliar que apunte al último nodo de la
lista
Nodo *aux = lista->ultimo;
// Usar un bucle while para ir retrocediendo el puntero
auxiliar por los nodos de la lista
while (aux != NULL) {
// Mostrar o procesar el valor del nodo actual
cout << aux->valor << " ";
// Retroceder el puntero auxiliar al nodo anterior
aux = aux->ant;
}
// Mostrar un salto de línea al final del recorrido
cout << endl;
}

04 // Actualizar listas según algún criterio

void actualizarListas(Lista *lista, int criterio, int nuevo) {
// Crear un puntero auxiliar que apunte al primer nodo de
la lista
Nodo *aux = lista->primero;
// Usar un bucle while para recorrer la lista con el puntero
auxiliar
while (aux != NULL) {
// Verificar si el valor del nodo actual cumple con el
criterio
if (aux->valor == criterio) {
// Si es así, cambiar el valor del nodo por uno nuevo
aux->valor = nuevo;
}
// Avanzar el puntero auxiliar al siguiente nodo
aux = aux->sig;
}
}