El concepto de lista enlazada se utiliza habitualmente en el mundo real. El concepto de listas enlazadas individualmente que aprendimos entra en juego cuando usamos Spotify para reproducir la siguiente canción de la cola. Pero, ¿qué puedes hacer exactamente para reproducir la canción anterior en la cola?
En este blog, aprenderemos sobre otro concepto relacionado con las estructuras de datos, a saber, la lista doblemente enlazada. También discutiremos la implementación usando lenguaje C y aplicaciones en tiempo real.
¿Qué es una lista doblemente enlazada?
Una lista enlazada es una estructura de datos lineal que contiene nodos conectados de forma secuencial. El nodo contiene tres campos, a saber, los datos almacenados en la dirección de referencia y dos punteros a los nodos sucesores a la izquierda y a la derecha del nodo de referencia.
El puntero del nodo izquierdo almacena la dirección de memoria del nodo anterior en la secuencia y el nodo derecho almacena la dirección de memoria del siguiente nodo. Aquí utilizamos asignación de memoria dinámica en lugar de matrices para que el tamaño de la memoria se pueda asignar o desasignar en tiempo de ejecución según las operaciones realizadas.
En este ejemplo, la cabeza apunta al primer nodo. El puntero izquierdo del nodo de referencia almacena NULL, al igual que el puntero derecho del último nodo.
Para operar en este ejemplo, podemos ir más allá y realizar los cambios correspondientes.
Implementación de lista doblemente enlazada.
1. Inserte el nodo al frente.
Para hacer lo anterior, primero cree un nodo y asigne memoria usando memoria dinámica. Apunte la cabeza al nuevo nodo y almacene valores NULL en los nodos izquierdo y derecho.
void front_add(){
//allocate memory using dynamic memory allocation.
newnode -> data = NULL;
newnode -> prev = NULL;
newnode -> next = head;
head= newnode;
}2. Eliminar el nodo frontal
Para eliminar un nodo del frente, tenemos que almacenar el valor de nodo correcto para la dirección de referencia en el encabezado y liberar el primer nodo.
void front_del(){
newnode=head;
head= head->next ;
head->prev = NULL;
free(newnode);
}3. Insertar nodo al final.
Para agregar un nodo al final, tenemos que recorrer hasta el final y apuntar el último nodo al nuevo nodo al que se hace referencia y viceversa.
void end_add(){
//allocate memory to newnode
newnode -> data= item; // temp=head
while(temp ->next !=NULL)
{
temp = temp->next;
}
temp->next= newnode;
newnode -> prev = temp;
newnode-> next = NULL;
}4. Eliminar el nodo final.
Para eliminar un nodo al final, tenemos que recorrer la lista enlazada y llegar al final. Usaremos un puntero al último segundo nodo. Luego suelte el último nodo.
void rear_del(){
while(temp -> next!=NULL)
{
temp = temp->next; //temp=head
}
temp ->prev-> next = NULL;
free(temp);
}Ahora que hemos entendido las operaciones básicas, implementaremos una lista doblemente enlazada en C paso a paso.
#include<stdio.h>
#define MAX 5
struct node{
int data;
struct node * prev;
struct node * next;
};
struct node *head;
void front_add();
void front_del();
void rear_add();
void rear_del();
void display();
int main(){
int choice=0;
while(choice!=6){
printf("enter choice:\n");
printf("\n1.front_add\n2.front_Del\n3.rear_add\n4.rear_del\n5.display\n6.exit");
scanf("%d\n",&choice);
switch(choice){
case 1:
front_add();
break;
case 2:
front_del();
break;
case 3:
rear_add();
break;
case 4:
rear_del();
break;
case 5:
display();
break;
case 6:
printf("exiting...\n");
break;
default:
printf("unknown choice\n");
}
}
}
void front_add(){
struct node* newnode;
int item;
newnode = (struct node*)malloc(sizeof(struct node));
printf("enter item value:\n");
scanf("%d", &item);
if(head == NULL)
{
newnode -> next = NULL;
newnode -> prev = NULL;
newnode -> data = item;
head = newnode;
}
else
{
newnode -> data = item;
newnode -> prev = NULL;
newnode -> next = head;
head->prev = newnode;
head= newnode;
}
}
void front_del(){
struct node *newnode;
if(head->next == NULL)
{
head = NULL;
free(head);
printf("\nnode deleted\n");
}
else
{
newnode=head;
head= head->next ;
head->prev = NULL;
free(newnode);
printf("deleted\n");
}
}
void rear_add(){
struct node *temp,*newnode;
int item;
newnode = (struct node*)malloc(sizeof(struct node));
printf("enter item");
scanf("%d", &item);
newnode -> data= item;
temp = head;
while(temp ->next !=NULL)
{
temp = temp->next;
}
temp->next= newnode;
newnode -> prev = temp;
newnode-> next = NULL;
printf("inserted\n");
}
void rear_del(){
struct node *temp;
temp=head;
if(head->next==NULL)
{
head = NULL;
free(head);
printf("deleted\n");
}
else{
while(temp -> next!=NULL)
{
temp = temp->next;
}
temp ->prev-> next = NULL;
free(temp);
printf("deleted\n");
}
}
void display(){
struct node *temp;
temp = head;
if(head==NULL)
{
printf("empty\n");
}
else{
while(temp!=NULL)
{
printf("%d", temp->data);
temp = temp->next;
}
}
}
Este código le dará el resultado deseado:
¿Alguna vez te has preguntado cómo se desarrollan estos juegos multijugador en los que los jugadores obtienen oportunidades en un bucle repetitivo? Esto significa que el último jugador se vincula nuevamente con el primer jugador para formar un bucle.
Para que esto sea posible, introducimos otro concepto relacionado con las listas enlazadas. En este caso, resulta útil una lista circular enlazada.
lista circular enlazada
En una lista circular individualmente enlazada, el último nodo de la lista enlazada contiene un puntero al primer nodo de la lista enlazada. Tanto las listas doblemente enlazadas como las simplemente enlazadas pueden utilizar este concepto.
La única diferencia entre esta lista y las otras dos es que el puntero derecho del último nodo apunta al primer nodo, mientras que el nodo principal siempre apunta al primer nodo.
en conclusión
En mi opinión, el concepto de lista enlazada es muy importante y útil para resolver problemas complejos. Tanto las listas doblemente enlazadas como las listas circulares enlazadas individualmente van de la mano cuando se atraviesan varios escenarios. Espero que disfrute leyendo este blog. Por favor, dale me gusta y comenta lo que piensas sobre el tema de hoy. ¡Feliz aprendizaje! !