
1. La lista enlazadas es un grupo de datos almacenados en una base llamada nodos y cada base contiene una cantidad de datos y un puntero que apunta hacia el siguiente nodo
1.1. Son importantes para la reutilizacion de codigo, la flexibilidad de el mismo, la mejora del rendimiento ademas de la abstraccion y la seguridad de los datos en el mismo
2. Nodos
3. Elemento de datos:
4. Puntero al siguiente nodo:
5. En una lista simple es el puntero que apunta al siguiente nodo
6. Almacena el valor o el dato que deseamos guardar en el
7. Operaciones Comunes
8. Ejemplo:
8.1. template plate <typename T> struct Nodo { T dato; Nodo* siguiente; Nodo(T valor) : dato(valor), siguiente(nullptr) {} };
9. Insercion:
10. Eliminacion:
11. Recorrido
12. Busqueda
13. La inserción es generalmente una operación constante, ya que solo se requieren ajustes de punteros. Para insertar un elemento en una lista enlazada, se pueden implementar diferentes métodos, como `insertarAlPrincipio`, `insertarAlFinal` o `insertarDespuésDe`, dependiendo de dónde se desee colocar el nuevo elemento.
13.1. despues de
13.1.1. void insertarDespuesDe(Nodo* cabeza, int valorBuscar, int nuevoValor) { Nodo* temp = cabeza; // Buscar el nodo con el valor deseado while (temp != nullptr && temp->dato != valorBuscar) { temp = temp->siguiente; } if (temp != nullptr) { // Si lo encontró Nodo* nuevoNodo = new Nodo(nuevoValor); nuevoNodo->siguiente = temp->siguiente; temp->siguiente = nuevoNodo; } else { cout << "Valor " << valorBuscar << " no encontrado en la lista." << endl; } }
13.2. inicio
13.2.1. void insertarAlPrincipio(T valor) { Nodo<T>* nuevoNodo = new Nodo<T>(valor); nuevoNodo->siguiente = cabeza; cabeza = nuevoNodo; }
13.3. final
13.3.1. void insertarAlFinal(Nodo*& cabeza, int valor) { Nodo* nuevoNodo = new Nodo(valor); if (cabeza == nullptr) { cabeza = nuevoNodo; return; } Nodo* temp = cabeza; while (temp->siguiente != nullptr) { temp = temp->siguiente; } temp->siguiente = nuevoNodo; }
14. El recorrido de una lista implica visitar todos los elementos uno por uno, para realizar alguna operación o para mostrar los elementos de la lista. Un bucle while suele ser utilizado para recorrer la lista desde el nodo inicial (cabeza) hasta el final (cuando el siguiente nodo es nulo).
14.1. void recorrer() { Nodo<T>* actual = cabeza; while (actual != nullptr) { // Realizar alguna operación con actual->dato std::cout << actual->dato << " "; actual = actual->siguiente; } std::cout << std::endl; }
15. La búsqueda de elementos en una lista enlazada implica recorrer la lista desde el nodo inicial hasta encontrar el elemento deseado o hasta llegar al final de la lista.
15.1. Nodo<T>* buscar(T valor) { Nodo<T>* actual = cabeza; while (actual != nullptr) { if (actual->dato == valor) { return actual; // Se encontró el elemento. } actual = actual->siguiente; } return nullptr; // Elemento no encontrado. }
16. es muy similar la operacion al de insertar pero con diferentes propositos y comando de codigo
16.1. void eliminarPorValor(T valor) { Nodo<T>* actual = cabeza; Nodo<T>* anterior = nullptr; while (actual != nullptr && actual->dato != valor) { anterior = actual; actual = actual->siguiente; } if (actual == nullptr) { // El elemento no se encontró en la lista. return; } if (anterior == nullptr) { // El elemento a eliminar es el primer nodo. cabeza = actual->siguiente; } else { // El elemento a eliminar está en medio o al final de la lista. anterior->siguiente = actual->siguiente; } delete actual; }
17. Nodo2
17.1. info
17.1.1. puntero hacia el siguiente
18. Nodo3
18.1. info
18.1.1. puntero hacia el siguiente
19. Null
20. Head
20.1. info:
20.1.1. puntero hacia el siguiente
21. Aplicaciones
21.1. Creación de tablas hash
21.1.1. Las listas enlazadas se utilizan para manejar colisiones en una tabla hash.
21.2. Gestión de memoria
21.2.1. Las listas enlazadas se pueden utilizar para implementar sistemas de gestión de memoria.
21.3. Algoritmos de manipulación de texto
21.3.1. Las listas enlazadas son útiles en editores de texto, donde se realizan inserciones y eliminaciones de caracteres o líneas.
21.4. Listas de adyacencia
21.4.1. En teoría de grafos, las listas enlazadas se utilizan para representar listas de adyacencia.
21.5. Implementación de pilas y colas
21.5.1. Las listas enlazadas son la base para implementar estas estructuras de datos.
21.6. Tablas de símbolos
21.6.1. En compiladores, las listas enlazadas se utilizan para almacenar y administrar variables y sus atributos.
22. ventajas
22.1. Inserción y eliminación eficientes:
22.1.1. Las listas enlazadas son ideales cuando necesitas realizar inserciones o eliminaciones frecuentes en el medio del codigo
22.2. Asignación dinámica de memoria:
22.2.1. Las listas enlazadas permiten una asignación dinámica de memoria, lo que significa que puedes agregar elementos según sea necesario sin preocuparte por la reserva añadida de memoria
22.3. Uso eficiente de memoria:
22.3.1. Las listas enlazadas son eficientes en términos de uso de memoria, ya que solo asignan memoria para los elementos que se necesitan
22.4. Tamaño dinámico:
22.4.1. Puedes crear listas enlazadas de tamaño dinámico, lo que las hace versátiles en situaciones en las que no sabes de antemano cuántos elementos necesitas almacenar