Listas enlazadas

Listas Enlazadas

En ciencias de la computación, una lista enlazada es una de las estructuras de datos fundamentales, y puede ser usada para implementar otras estructuras de datos.

Consiste en una secuencia de nodos, en los que se guardan campos de datos arbitrarios y una o dos referencias, enlaces o punteros al nodo anterior o posterior.

Una lista enlazada es un tipo de dato autorreferenciado porque contienen un puntero o enlace (en inglés link, del mismo significado) a otro dato del mismo tipo.

Las listas enlazadas pueden ser implementadas en muchos lenguajes. Lenguajes tales como Lisp, Scheme y Haskell tienen estructuras de datos ya construidas, junto con operaciones para acceder a las listas enlazadas. Lenguajes imperativos u orientados a objetos tales como C o C++ y Java, respectivamente, disponen de referencias para crear listas enlazadas.

HISTORIA

Las listas enlazadas fueron desarrolladas en 1955-56 por Cliff Shaw y Herbert Simón en RAND Corporation, como la principal estructura de datos para su Lenguaje de Procesamiento de la Información (IPL). Se publicó en IRE Transactions on Information Theory en 1956, y en distintas conferencias entre 1957-1959, incluida Proceedings of the Western Joint Computer en 1957 y 1958

El diagrama clásico actual, que consiste en bloques que representan nodos de la lista con flechas apuntando a los sucesivos nodos de la lista, apareció en Programming the Logic Theory Machine, de Newell y Shaw.

LISP, el principal procesador de listas, fue creado en 1958. Una de las principales estructuras de datos de LISP es la lista enlazada.

Tipos de listas

Listas simples enlazadas

Una variable de referencia contiene una referencia al primer nodo, cada nodo (excepto el último) enlaza con el nodo siguiente, y el enlace del último nodo contiene NULL para indicar el final de la lista.

Listas doblemente enlazadas

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 valor NULL si es el último nodo.

Listas enlazadas circulares

En una lista enlazada circular, el primer y el último nodo están unidos juntos

Listas enlazadas simples circulares

Cada nodo tiene un enlace, similar al de las listas enlazadas simples, excepto que el siguiente nodo del último apunta al primero.

Listas enlazadas doblemente circulares

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.

Nodos centinelas

Su propósito es simplificar o agilizar algunas operaciones, asegurando que cualquier nodo tiene otro anterior o posterior, y que toda la lista (incluso alguna que no contenga datos) siempre tenga un

Características

Los elementos se distribuyen de forma dispersa por la memoria: Los bloques de información no ocupan posiciones consecutivas en la memoria. El orden de la lista la establecen los enlaces entre bloques de información.

Acceso a los elementos aleatorio: Puede extraerse información de cualquier elemento o insertar un bloque en cualquier posición.

Acceso a los elementos no destructivo: Al contrario que en colas y pilas, la extracción de un bloque no implica su eliminación.

El tamaño de la lista puede modificarse de forma dinámica: Al contrario que en colas y pilas, no hay un número máximo de elementos de la lista (salvo limitaciones de la capacidad de almacenamiento de la máquina).

Ventajas y desventajas

Ventajas Ventajas

Flexibilidad en la inserción y eliminación de elementos

Una lista enlazada permite la inserción y eliminación eficiente de elementos en cualquier posición de la lista, ya que solo se requieren modificaciones en los enlaces de los nodos adyacentes.

Uso eficiente de memoria

Las listas enlazadas utilizan memoria de manera eficiente, ya que solo se asigna memoria para cada elemento y su enlace.

Tamaño variable

A diferencia de las listas estáticas, que tienen un tamaño fijo determinado en tiempo de compilación, las listas enlazadas pueden crecer o reducirse según sea necesario durante la ejecución del programa.

Acceso secuencial

Una lista enlazada permite la inserción y eliminación eficiente de elementos en cualquier posición de la lista, ya que solo se requieren modificaciones en los enlaces de los nodos adyacentes. Uso adicional de memoria

Además de los elementos que se almacenan en la lista enlazada, cada nodo también requiere un enlace adicional para apuntar al siguiente nodo.

Complejidad de implementación

Las listas enlazadas pueden requerir una implementación más compleja en comparación con las listas estáticas o arrays

Formas de implementación En la programación

Listas enlazadas simples

Ejercicios

Una biblioteca, desea llevar un registro de los libros que tiene, se sabe que existen un número no mayor a 100 libros y que los datos que se necesitan registrar son el (Nombre del autor del libro, el título del libro y la existencia del mismo. Dichos datos se deben de guardar de manera lineal.

<!DOCTYPE html>

<html>

<head>

<title>Registro de Libros</title>

<script>

// Definición de una función para agregar un libro al registro function agregarLibro() {

// Obtener los valores ingresados por el usuario var autor = document.getElementById("autor").value; var titulo = document.getElementById("titulo").value; var existencia = document.getElementById("existencia").value;

// Validar que los campos no estén vacíos if (autor === "" || titulo === "" || existencia === "") { alert("Por favor, completa todos los campos."); return; }

// Crear un objeto libro con los datos ingresados var libro = { autor: autor, titulo: titulo, existencia: existencia };

// Obtener el elemento de la tabla donde se mostrarán los libros var tabla = document.getElementById("tablaLibros");

// Crear una nueva fila y celdas para mostrar los datos del libro var fila = tabla.insertRow(); var celdaAutor = fila.insertCell(); var celdaTitulo = fila.insertCell(); var celdaExistencia = fila.insertCell();

// Asignar los valores a las celdas celdaAutor.innerHTML = libro.autor; celdaTitulo.innerHTML = libro.titulo; celdaExistencia.innerHTML = libro.existencia;

// Limpiar los campos de entrada document.getElementById("autor").value = ""; document.getElementById("titulo").value = ""; document.getElementById("existencia").value = "";

</script>

</head>

<body>

<h1>Registro de Libros</h1>

<label for="autor">Autor:</label>

<input type="text" id="autor" placeholder="Nombre del autor"><br>

<label for="titulo">Título:</label>

<input type="text" id="titulo" placeholder="Título del libro"><br>

<label for="existencia">Existencia:</label>

<input type="number" id="existencia" placeholder="Cantidad disponible"><br>

<button onclick="agregarLibro()">Agregar Libro</button>

<h2>Lista de Libros</h2>

<table id="tablaLibros" border="1">

<tr> <th>Autor</th> <th>Título</th> <th>Existencia</th>

</tr> </table> </body> </html>

Elabore un registro para n alumnos de una Universidad, con sus respectivas notas de Programación II y Estructura de datos, dichos datos, se deben guardar en una lista lineal. Se sabe que, en ésta Universidad, existe a política que sí, un alumno ha reprobado estas dos materias, es dado de baja en la universidad. (Nota mínima 9.5)

#include<iostream>

#include<conio.h>

#include<stdlib.h>

using namespace std;

struct Nodo{ int dato;

struct Nodo *siguiente; };

//Prototipos de funciones

void menu();

void insertarLista (Nodo *&, float n1, float n2);

void mostrarLista (Nodo *);

void eliminarLista (Nodo *, float);

Nodo *lista = NULL;

int main(){ menu(); getch(); return 0; }

void menu(){ int opcion; float notaprogII, notaestrucd, borrar; do{

cout<<"\t.:MENU:.\n";

cout<<"1.Insertar notas del alumno\n";

cout<<"2.Mostrar notas del alumno\n";

cout<<"3.Eliminar notas del alumno\n";

cout<<"4.Salir\n";

cout<<"Opcion: "; cin>>opcion;

switch (opcion){

case 1 : cout<<"\nDigite la nota final de Programacion II: "; cin>> notaprogII; cout<<"\nDigite la nota final de Estructura de datos: "; cin>> notaestrucd; if ((notaprogII <= 9.5) && (notaestrucd <= 9.5)){ cout<<"\tEl alumno reprobo ambas materias, por lo tanto se le dara de baja en la universidad\n"; cout<<"\n"; system ("pause");

} else{

insertarLista (lista, notaprogII, notaestrucd); cout<<"\n"; system ("pause");

} break;

case 2 : mostrarLista (lista); cout<<"\n"; system ("pause"); break;

case 3 : cout<<"\nDigite el elemento que desea eliminar: "; cin>>borrar; eliminarLista(lista, borrar); cout<<"\n"; system ("pause");

} system ("cls"); }while(opcion!=4); }

void insertarLista (Nodo *&lista, float notaprogII, float notaestrucd){

Nodo *nuevo_nodo = new Nodo();

nuevo_nodo->dato = notaprogII; nuevo_nodo->dato = notaestrucd;

Nodo *aux1 = lista;

Nodo *aux2;

while ((aux1 != NULL) && (aux1->dato < notaestrucd) && (aux1->dato < notaprogII)){ aux2 = aux1; aux1 = aux1->siguiente; }

if (lista == aux1){ lista = nuevo_nodo; }

else{

aux2->siguiente = nuevo_nodo; }

nuevo_nodo->siguiente = aux1; cout<<"\tNotas agregadas correctamente\n"; };

void mostrarLista (Nodo *lista){

Nodo *actual = new Nodo(); actual = lista; int i = 0;

while(actual != NULL) {

cout <<' '<< i+1 <<") " << actual->dato << endl; actual = actual->siguiente; i++;

void eliminarLista (Nodo *lista, float n){ if (lista !=NULL){

Nodo *aux_borrar; Nodo *anterior = NULL;

aux_borrar = lista;

while((aux_borrar != NULL) && (aux_borrar->dato != n)){ anterior = aux_borrar; aux_borrar = aux_borrar->siguiente;

if (aux_borrar == NULL){

cout<<"El Elemento no se encuentra en la lista";

else if (anterior == NULL){ lista = lista->siguiente; delete aux_borrar;

else{ anterior->siguiente = aux_borrar->siguiente;