Una lista enlazada es una estructura de datos lineal, en la que los elementos no se almacenan en ubicaciones de memoria contiguas. Los elementos de una lista enlazada se enlazan mediante punteros . En palabras simples, una lista enlazada consta de Nodes donde cada Node contiene un campo de datos y una referencia (enlace) al siguiente Node de la lista.
Tipos de lista enlazada
- Lista enlazada individualmente: es el tipo más simple de lista enlazada en la que cada Node contiene algunos datos y un puntero al siguiente Node del mismo tipo de datos. El Node contiene un puntero al siguiente Node, lo que significa que el Node almacena la dirección del siguiente Node en la secuencia. Una sola lista enlazada permite el cruce de datos solo de una manera. A continuación se muestra la imagen de la misma:
- Estructura de la lista de enlaces individuales :
C++
// Node of a doubly linked list
class Node {
public:
int data;
// Pointer to next node in LL
Node* next;
};
Java
// Node of a doubly linked list
static class Node
{
int data;
// Pointer to next node in LL
Node next;
};
//this code is contributed by shivani
Python3
# structure of Node class Node: def __init__(self, data): self.data = data self.next = None
C#
// Structure of Node
public class Node
{
public int data;
// Pointer to next node in LL
public Node next;
};
//this code is contributed by shivanisinghss2110
Javascript
// Node of a doubly linked list
class Node
{
constructor()
{
this.data=0;
// Pointer to next node
this.next=null;
}
}
// This code is contributed by SHUBHAMSINGH10
- Creación y recorrido de una lista enlazada individualmente :
C++
// C++ program to illustrate creation
// and traversal of Singly Linked List
#include <bits/stdc++.h>
using namespace std;
// Structure of Node
class Node {
public:
int data;
Node* next;
};
// Function to print the content of
// linked list starting from the
// given node
void printList(Node* n)
{
// Iterate till n reaches NULL
while (n != NULL) {
// Print the data
cout << n->data << " ";
n = n->next;
}
}
// Driver Code
int main()
{
Node* head = NULL;
Node* second = NULL;
Node* third = NULL;
// Allocate 3 nodes in the heap
head = new Node();
second = new Node();
third = new Node();
// Assign data in first node
head->data = 1;
// Link first node with second
head->next = second;
// Assign data to second node
second->data = 2;
second->next = third;
// Assign data to third node
third->data = 3;
third->next = NULL;
printList(head);
return 0;
}
Java
// Java program to illustrate
// creation and traversal of
// Singly Linked List
class GFG{
// Structure of Node
static class Node
{
int data;
Node next;
};
// Function to print the content of
// linked list starting from the
// given node
static void printList(Node n)
{
// Iterate till n reaches null
while (n != null)
{
// Print the data
System.out.print(n.data + " ");
n = n.next;
}
}
// Driver Code
public static void main(String[] args)
{
Node head = null;
Node second = null;
Node third = null;
// Allocate 3 nodes in
// the heap
head = new Node();
second = new Node();
third = new Node();
// Assign data in first
// node
head.data = 1;
// Link first node with
// second
head.next = second;
// Assign data to second
// node
second.data = 2;
second.next = third;
// Assign data to third
// node
third.data = 3;
third.next = null;
printList(head);
}
}
// This code is contributed by Princi Singh
C#
// C# program to illustrate
// creation and traversal of
// Singly Linked List
using System;
class GFG{
// Structure of Node
public class Node
{
public int data;
public Node next;
};
// Function to print the content of
// linked list starting from the
// given node
static void printList(Node n)
{
// Iterate till n reaches null
while (n != null)
{
// Print the data
Console.Write(n.data + " ");
n = n.next;
}
}
// Driver Code
public static void Main(String[] args)
{
Node head = null;
Node second = null;
Node third = null;
// Allocate 3 nodes in
// the heap
head = new Node();
second = new Node();
third = new Node();
// Assign data in first
// node
head.data = 1;
// Link first node with
// second
head.next = second;
// Assign data to second
// node
second.data = 2;
second.next = third;
// Assign data to third
// node
third.data = 3;
third.next = null;
printList(head);
}
}
// This code is contributed by Amit Katiyar
Python3
# structure of Node class Node: def __init__(self, data): self.data = data self.next = None class LinkedList: def __init__(self): self.head = None self.last_node = None # function to add elements to linked list def append(self, data): # if linked list is empty then last_node will be none so in if condition head will be created if self.last_node is None: self.head = Node(data) self.last_node = self.head # adding node to the tail of linked list else: self.last_node.next = Node(data) self.last_node = self.last_node.next # function to print the content of linked list def display(self): current = self.head # traversing the linked list while current is not None: # at each node printing its data print(current.data, end=' ') # giving current next node current = current.next print() if __name__ == '__main__': L = LinkedList() # adding elements to the linked list L.append(1) L.append(2) L.append(3) L.append(4) # displaying elements of linked list L.display()
Javascript
<script>
// JavaScript program to illustrate
// creation and traversal of
// Singly Linked List
// Structure of Node
class Node
{
constructor()
{
this.data=0;
this.next=null;
}
}
// Function to print the content of
// linked list starting from the
// given node
function printList(n)
{
// Iterate till n reaches null
while (n != null)
{
// Print the data
document.write(n.data + " ");
n = n.next;
}
}
// Driver Code
let head = null;
let second = null;
let third = null;
// Allocate 3 nodes in
// the heap
head = new Node();
second = new Node();
third = new Node();
// Assign data in first
// node
head.data = 1;
// Link first node with
// second
head.next = second;
// Assign data to second
// node
second.data = 2;
second.next = third;
// Assign data to third
// node
third.data = 3;
third.next = null;
printList(head);
// This code is contributed by unknown2108
</script>
Producción
1 2 3
- Lista doblemente enlazada: una lista doblemente enlazada o una lista enlazada bidireccional es un tipo más complejo de lista enlazada que contiene un puntero al siguiente Node así como al anterior en secuencia. Por lo tanto, contiene tres partes: datos, un puntero al Node siguiente y un puntero al Node anterior. Esto nos permitiría recorrer la lista también hacia atrás. A continuación se muestra la imagen de la misma:
- Estructura de la lista doblemente enlazada :
C++
// Node of a doubly linked list
struct Node {
int data;
// Pointer to next node in DLL
struct Node* next;
// Pointer to the previous node in DLL
struct Node* prev;
};
Java
// Doubly linked list
// node
static class Node
{
int data;
// Pointer to next node in DLL
Node next;
// Pointer to the previous node in DLL
Node prev;
};
// This code is contributed by shivani
Python3
# structure of Node class Node: def __init__(self, data): self.previous = None self.data = data self.next = None
C#
// Doubly linked list
// node
public class Node
{
public int data;
// Pointer to next node in DLL
public Node next;
// Pointer to the previous node in DLL
public Node prev;
};
// This code is contributed by shivanisinghss2110
- Creación y recorrido de la lista doblemente enlazada :
C++
// C++ program to illustrate creation
// and traversal of Doubly Linked List
#include <bits/stdc++.h>
using namespace std;
// Doubly linked list node
class Node {
public:
int data;
Node* next;
Node* prev;
};
// Function to push a new element in
// the Doubly Linked List
void push(Node** head_ref, int new_data)
{
// Allocate node
Node* new_node = new Node();
// Put in the data
new_node->data = new_data;
// Make next of new node as
// head and previous as NULL
new_node->next = (*head_ref);
new_node->prev = NULL;
// Change prev of head node to
// the new node
if ((*head_ref) != NULL)
(*head_ref)->prev = new_node;
// Move the head to point to
// the new node
(*head_ref) = new_node;
}
// Function to traverse the Doubly LL
// in the forward & backward direction
void printList(Node* node)
{
Node* last;
cout << "\nTraversal in forward"
<< " direction \n";
while (node != NULL) {
// Print the data
cout << " " << node->data << " ";
last = node;
node = node->next;
}
cout << "\nTraversal in reverse"
<< " direction \n";
while (last != NULL) {
// Print the data
cout << " " << last->data << " ";
last = last->prev;
}
}
// Driver Code
int main()
{
// Start with the empty list
Node* head = NULL;
// Insert 6.
// So linked list becomes 6->NULL
push(&head, 6);
// Insert 7 at the beginning. So
// linked list becomes 7->6->NULL
push(&head, 7);
// Insert 1 at the beginning. So
// linked list becomes 1->7->6->NULL
push(&head, 1);
cout << "Created DLL is: ";
printList(head);
return 0;
}
Java
// Java program to illustrate
// creation and traversal of
// Doubly Linked List
import java.util.*;
class GFG{
// Doubly linked list
// node
static class Node
{
int data;
Node next;
Node prev;
};
static Node head_ref;
// Function to push a new
// element in the Doubly
// Linked List
static void push(int new_data)
{
// Allocate node
Node new_node = new Node();
// Put in the data
new_node.data = new_data;
// Make next of new node as
// head and previous as null
new_node.next = head_ref;
new_node.prev = null;
// Change prev of head node to
// the new node
if (head_ref != null)
head_ref.prev = new_node;
// Move the head to point to
// the new node
head_ref = new_node;
}
// Function to traverse the
// Doubly LL in the forward
// & backward direction
static void printList(Node node)
{
Node last = null;
System.out.print("\nTraversal in forward" +
" direction \n");
while (node != null)
{
// Print the data
System.out.print(" " + node.data +
" ");
last = node;
node = node.next;
}
System.out.print("\nTraversal in reverse" +
" direction \n");
while (last != null)
{
// Print the data
System.out.print(" " + last.data +
" ");
last = last.prev;
}
}
// Driver Code
public static void main(String[] args)
{
// Start with the empty list
head_ref = null;
// Insert 6.
// So linked list becomes
// 6.null
push(6);
// Insert 7 at the beginning.
// So linked list becomes
// 7.6.null
push(7);
// Insert 1 at the beginning.
// So linked list becomes
// 1.7.6.null
push(1);
System.out.print("Created DLL is: ");
printList(head_ref);
}
}
// This code is contributed by Princi Singh
Python3
# structure of Node
class Node:
def __init__(self, data):
self.previous = None
self.data = data
self.next = None
class DoublyLinkedList:
def __init__(self):
self.head = None
self.start_node = None
self.last_node = None
# function to add elements to doubly linked list
def append(self, data):
# is doubly linked list is empty then last_node will be none so in if condition head will be created
if self.last_node is None:
self.head = Node(data)
self.last_node = self.head
# adding node to the tail of doubly linked list
else:
new_node = Node(data)
self.last_node.next = new_node
new_node.previous = self.last_node
new_node.next = None
self.last_node = new_node
# function to printing and traversing the content of doubly linked list from left to right and right to left
def display(self, Type):
if Type == 'Left_To_Right':
current = self.head
while current is not None:
print(current.data, end=' ')
current = current.next
print()
else:
current = self.last_node
while current is not None:
print(current.data, end=' ')
current = current.previous
print()
if __name__ == '__main__':
L = DoublyLinkedList()
L.append(1)
L.append(2)
L.append(3)
L.append(4)
L.display('Left_To_Right')
L.display('Right_To_Left')
C#
// C# program to illustrate
// creation and traversal of
// Doubly Linked List
using System;
class GFG{
// Doubly linked list
// node
public class Node
{
public int data;
public Node next;
public Node prev;
};
static Node head_ref;
// Function to push a new
// element in the Doubly
// Linked List
static void push(int new_data)
{
// Allocate node
Node new_node = new Node();
// Put in the data
new_node.data = new_data;
// Make next of new node as
// head and previous as null
new_node.next = head_ref;
new_node.prev = null;
// Change prev of head node to
// the new node
if (head_ref != null)
head_ref.prev = new_node;
// Move the head to point to
// the new node
head_ref = new_node;
}
// Function to traverse the
// Doubly LL in the forward
// & backward direction
static void printList(Node node)
{
Node last = null;
Console.Write("\nTraversal in forward" +
" direction \n");
while (node != null)
{
// Print the data
Console.Write(" " + node.data +
" ");
last = node;
node = node.next;
}
Console.Write("\nTraversal in reverse" +
" direction \n");
while (last != null)
{
// Print the data
Console.Write(" " + last.data +
" ");
last = last.prev;
}
}
// Driver Code
public static void Main(String[] args)
{
// Start with the empty list
head_ref = null;
// Insert 6.
// So linked list becomes
// 6.null
push(6);
// Insert 7 at the beginning.
// So linked list becomes
// 7.6.null
push(7);
// Insert 1 at the beginning.
// So linked list becomes
// 1.7.6.null
push(1);
Console.Write("Created DLL is: ");
printList(head_ref);
}
}
// This code is contributed by Amit Katiyar
Producción
Created DLL is: Traversal in forward direction 1 7 6 Traversal in reverse direction 6 7 1
- Lista enlazada circular: Una lista enlazada circular es aquella en la que el último Node contiene el puntero al primer Node de la lista. Mientras recorremos una lista enlazada circular, podemos comenzar en cualquier Node y recorrer la lista en cualquier dirección hacia adelante y hacia atrás hasta llegar al mismo Node en el que comenzamos. Por lo tanto, una lista enlazada circular no tiene principio ni fin. A continuación se muestra la imagen de la misma:
- Estructura de la lista enlazada circular :
C++
// Structure for a node
class Node {
public:
int data;
// Pointer to next node in CLL
Node* next;
};
Java
// Structure for a node
static class Node
{
int data;
// Pointer to next node in CLL
Node next;
};
// This code is contributed by shivanisinghss2110
Python3
# structure of Node class Node: def __init__(self, data): self.data = data self.next = None
C#
// Structure for a node
public class Node
{
public int data;
// Pointer to next node in CLL
public Node next;
};
// This code is contributed by shivanisinghss2110
- Creación y cruce de la lista enlazada circular :
C++
// C++ program to illustrate creation
// and traversal of Circular LL
#include <bits/stdc++.h>
using namespace std;
// Structure for a node
class Node {
public:
int data;
Node* next;
};
// Function to insert a node at the
// beginning of Circular LL
void push(Node** head_ref, int data)
{
Node* ptr1 = new Node();
Node* temp = *head_ref;
ptr1->data = data;
ptr1->next = *head_ref;
// If linked list is not NULL then
// set the next of last node
if (*head_ref != NULL) {
while (temp->next != *head_ref) {
temp = temp->next;
}
temp->next = ptr1;
}
// For the first node
else
ptr1->next = ptr1;
*head_ref = ptr1;
}
// Function to print nodes in the
// Circular Linked List
void printList(Node* head)
{
Node* temp = head;
if (head != NULL) {
do {
// Print the data
cout << temp->data << " ";
temp = temp->next;
} while (temp != head);
}
}
// Driver Code
int main()
{
// Initialize list as empty
Node* head = NULL;
// Created linked list will
// be 11->2->56->12
push(&head, 12);
push(&head, 56);
push(&head, 2);
push(&head, 11);
cout << "Contents of Circular"
<< " Linked List\n ";
printList(head);
return 0;
}
Java
// Java program to illustrate
// creation and traversal of
// Circular LL
import java.util.*;
class GFG{
// Structure for a
// node
static class Node
{
int data;
Node next;
};
// Function to insert a node
// at the beginning of Circular
// LL
static Node push(Node head_ref,
int data)
{
Node ptr1 = new Node();
Node temp = head_ref;
ptr1.data = data;
ptr1.next = head_ref;
// If linked list is not
// null then set the next
// of last node
if (head_ref != null)
{
while (temp.next != head_ref)
{
temp = temp.next;
}
temp.next = ptr1;
}
// For the first node
else
ptr1.next = ptr1;
head_ref = ptr1;
return head_ref;
}
// Function to print nodes in
// the Circular Linked List
static void printList(Node head)
{
Node temp = head;
if (head != null)
{
do
{
// Print the data
System.out.print(temp.data + " ");
temp = temp.next;
} while (temp != head);
}
}
// Driver Code
public static void main(String[] args)
{
// Initialize list as empty
Node head = null;
// Created linked list will
// be 11.2.56.12
head = push(head, 12);
head = push(head, 56);
head = push(head, 2);
head = push(head, 11);
System.out.print("Contents of Circular" +
" Linked List\n ");
printList(head);
}
}
// This code is contributed by gauravrajput1
Python3
# structure of Node class Node: def __init__(self, data): self.data = data self.next = None class CircularLinkedList: def __init__(self): self.head = None self.last_node = None # function to add elements to circular linked list def append(self, data): # is circular linked list is empty then last_node will be none so in if condition head will be created if self.last_node is None: self.head = Node(data) self.last_node = self.head # adding node to the tail of circular linked list else: self.last_node.next = Node(data) self.last_node = self.last_node.next self.last_node.next = self.head # function to print the content of circular linked list def display(self): current = self.head while current is not None: print(current.data, end=' ') current = current.next if current == self.head: break print() if __name__ == '__main__': L = CircularLinkedList() L.append(1) L.append(2) L.append(3) L.append(4) L.display()
C#
// C# program to illustrate
// creation and traversal of
// Circular LL
using System;
class GFG{
// Structure for a
// node
public class Node
{
public int data;
public Node next;
};
// Function to insert a node
// at the beginning of Circular
// LL
static Node push(Node head_ref,
int data)
{
Node ptr1 = new Node();
Node temp = head_ref;
ptr1.data = data;
ptr1.next = head_ref;
// If linked list is not
// null then set the next
// of last node
if (head_ref != null)
{
while (temp.next != head_ref)
{
temp = temp.next;
}
temp.next = ptr1;
}
// For the first node
else
ptr1.next = ptr1;
head_ref = ptr1;
return head_ref;
}
// Function to print nodes in
// the Circular Linked List
static void printList(Node head)
{
Node temp = head;
if (head != null)
{
do
{
// Print the data
Console.Write(temp.data + " ");
temp = temp.next;
} while (temp != head);
}
}
// Driver Code
public static void Main(String[] args)
{
// Initialize list as empty
Node head = null;
// Created linked list will
// be 11.2.56.12
head = push(head, 12);
head = push(head, 56);
head = push(head, 2);
head = push(head, 11);
Console.Write("Contents of Circular " +
"Linked List\n ");
printList(head);
}
}
// This code is contributed by gauravrajput1
Producción
Contents of Circular Linked List 11 2 56 12
- Lista enlazada doblemente circular: una lista enlazada doblemente circular o una lista enlazada circular bidireccional es un tipo más complejo de lista enlazada que contiene un puntero al siguiente Node así como al anterior en la secuencia. La diferencia entre la lista doblemente enlazada y la doblemente circular es la misma que entre una lista enlazada simple y una lista enlazada circular. La lista circular doblemente enlazada no contiene nulo en el campo anterior del primer Node. A continuación se muestra la imagen de la misma:
- Estructura de la lista enlazada doblemente circular :
C++
// Node of doubly circular linked list
struct Node {
int data;
// Pointer to next node in DCLL
struct Node* next;
// Pointer to the previous node in DCLL
struct Node* prev;
};
Java
// Structure of a Node
static class Node
{
int data;
// Pointer to next node in DCLL
Node next;
// Pointer to the previous node in DCLL
Node prev;
};
//this code is contributed by shivanisinghss2110
Python3
# structure of Node class Node: def __init__(self, data): self.previous = None self.data = data self.next = None
C#
// Structure of a Node
public class Node
{
public int data;
// Pointer to next node in DCLL
public Node next;
// Pointer to the previous node in DCLL
public Node prev;
};
// This code is contributed by shivanisinghss2110
- Creación y recorrido de la lista enlazada doblemente circular :
C++
// C++ program to illustrate creation
// & traversal of Doubly Circular LL
#include <bits/stdc++.h>
using namespace std;
// Structure of a Node
struct Node {
int data;
struct Node* next;
struct Node* prev;
};
// Function to insert Node at
// the beginning of the List
void insertBegin(struct Node** start,
int value)
{
// If the list is empty
if (*start == NULL) {
struct Node* new_node = new Node;
new_node->data = value;
new_node->next
= new_node->prev = new_node;
*start = new_node;
return;
}
// Pointer points to last Node
struct Node* last = (*start)->prev;
struct Node* new_node = new Node;
// Inserting the data
new_node->data = value;
// Update the previous and
// next of new node
new_node->next = *start;
new_node->prev = last;
// Update next and previous
// pointers of start & last
last->next = (*start)->prev
= new_node;
// Update start pointer
*start = new_node;
}
// Function to traverse the circular
// doubly linked list
void display(struct Node* start)
{
struct Node* temp = start;
printf("\nTraversal in"
" forward direction \n");
while (temp->next != start) {
printf("%d ", temp->data);
temp = temp->next;
}
printf("%d ", temp->data);
printf("\nTraversal in "
"reverse direction \n");
Node* last = start->prev;
temp = last;
while (temp->prev != last) {
// Print the data
printf("%d ", temp->data);
temp = temp->prev;
}
printf("%d ", temp->data);
}
// Driver Code
int main()
{
// Start with the empty list
struct Node* start = NULL;
// Insert 5
// So linked list becomes 5->NULL
insertBegin(&start, 5);
// Insert 4 at the beginning
// So linked list becomes 4->5
insertBegin(&start, 4);
// Insert 7 at the end
// So linked list becomes 7->4->5
insertBegin(&start, 7);
printf("Created circular doubly"
" linked list is: ");
display(start);
return 0;
}
Java
// Java program to illustrate creation
// & traversal of Doubly Circular LL
import java.util.*;
class GFG{
// Structure of a Node
static class Node
{
int data;
Node next;
Node prev;
};
// Start with the empty list
static Node start = null;
// Function to insert Node at
// the beginning of the List
static void insertBegin(
int value)
{
// If the list is empty
if (start == null)
{
Node new_node = new Node();
new_node.data = value;
new_node.next
= new_node.prev = new_node;
start = new_node;
return;
}
// Pointer points to last Node
Node last = (start).prev;
Node new_node = new Node();
// Inserting the data
new_node.data = value;
// Update the previous and
// next of new node
new_node.next = start;
new_node.prev = last;
// Update next and previous
// pointers of start & last
last.next = (start).prev
= new_node;
// Update start pointer
start = new_node;
}
// Function to traverse the circular
// doubly linked list
static void display()
{
Node temp = start;
System.out.printf("\nTraversal in"
+" forward direction \n");
while (temp.next != start)
{
System.out.printf("%d ", temp.data);
temp = temp.next;
}
System.out.printf("%d ", temp.data);
System.out.printf("\nTraversal in "
+ "reverse direction \n");
Node last = start.prev;
temp = last;
while (temp.prev != last)
{
// Print the data
System.out.printf("%d ", temp.data);
temp = temp.prev;
}
System.out.printf("%d ", temp.data);
}
// Driver Code
public static void main(String[] args)
{
// Insert 5
// So linked list becomes 5.null
insertBegin( 5);
// Insert 4 at the beginning
// So linked list becomes 4.5
insertBegin( 4);
// Insert 7 at the end
// So linked list becomes 7.4.5
insertBegin( 7);
System.out.printf("Created circular doubly"
+ " linked list is: ");
display();
}
}
// This code is contributed by shikhasingrajput
Python3
# structure of Node
class Node:
def __init__(self, data):
self.previous = None
self.data = data
self.next = None
class DoublyLinkedList:
def __init__(self):
self.head = None
self.start_node = None
self.last_node = None
# function to add elements to doubly linked list
def append(self, data):
# is doubly linked list is empty then last_node will be none so in if condition head will be created
if self.last_node is None:
self.head = Node(data)
self.last_node = self.head
# adding node to the tail of doubly linked list
else:
new_node = Node(data)
self.last_node.next = new_node
new_node.previous = self.last_node
new_node.next = self.head
self.head.previous = new_node
self.last_node = new_node
# function to print the content of doubly linked list
def display(self, Type = 'Left_To_Right'):
if Type == 'Left_To_Right':
current = self.head
while current.next is not None:
print(current.data, end=' ')
current = current.next
if current == self.head:
break
print()
else:
current = self.last_node
while current.previous is not None:
print(current.data, end=' ')
current = current.previous
if current == self.last_node.next:
print(self.last_node.next.data, end=' ')
break
print()
if __name__ == '__main__':
L = DoublyLinkedList()
L.append(1)
L.append(2)
L.append(3)
L.append(4)
L.display('Left_To_Right')
L.display('Right_To_Left')
C#
// C# program to illustrate creation
// & traversal of Doubly Circular LL
using System;
public class GFG{
// Structure of a Node
public
class Node
{
public
int data;
public
Node next;
public
Node prev;
};
// Start with the empty list
static Node start = null;
// Function to insert Node at
// the beginning of the List
static void insertBegin(
int value)
{
Node new_node = new Node();
// If the list is empty
if (start == null)
{
new_node.data = value;
new_node.next
= new_node.prev = new_node;
start = new_node;
return;
}
// Pointer points to last Node
Node last = (start).prev;
// Inserting the data
new_node.data = value;
// Update the previous and
// next of new node
new_node.next = start;
new_node.prev = last;
// Update next and previous
// pointers of start & last
last.next = (start).prev
= new_node;
// Update start pointer
start = new_node;
}
// Function to traverse the circular
// doubly linked list
static void display()
{
Node temp = start;
Console.Write("\nTraversal in"
+" forward direction \n");
while (temp.next != start)
{
Console.Write(temp.data + " ");
temp = temp.next;
}
Console.Write(temp.data + " ");
Console.Write("\nTraversal in "
+ "reverse direction \n");
Node last = start.prev;
temp = last;
while (temp.prev != last)
{
// Print the data
Console.Write( temp.data + " ");
temp = temp.prev;
}
Console.Write( temp.data + " ");
}
// Driver Code
public static void Main(String[] args)
{
// Insert 5
// So linked list becomes 5.null
insertBegin( 5);
// Insert 4 at the beginning
// So linked list becomes 4.5
insertBegin( 4);
// Insert 7 at the end
// So linked list becomes 7.4.5
insertBegin( 7);
Console.Write("Created circular doubly"
+ " linked list is: ");
display();
}
}
// This code is contributed by 29AjayKumar
Producción
Created circular doubly linked list is: Traversal in forward direction 7 4 5 Traversal in reverse direction 5 4 7
- Lista enlazada de encabezado: una lista enlazada de encabezado es un tipo especial de lista enlazada que contiene un Node de encabezado al principio de la lista. Por lo tanto, en una lista enlazada de encabezado, INICIO no apuntará al primer Node de la lista, pero INICIO contendrá la dirección del Node de encabezado. A continuación se muestra la imagen de la lista enlazada de encabezado conectado a tierra:
- Estructura de la lista enlazada de encabezado conectado a tierra :
C++
// Structure of the list
struct link {
int info;
// Pointer to the next node
struct link* next;
};
Python3
# structure of Node class Node: def __init__(self, data): self.data = data self.next = None
Java
// Structure of the list
static class link {
int info;
// Pointer to the next node
link next;
};
// this code is contributed by shivanisinghss2110
C#
// Structure of the list
public class link {
public int info;
// Pointer to the next node
public link next;
};
// this code is contributed by shivanisinghss2110
- Creación y cruce de la lista enlazada de encabezados :
C++
// C++ program to illustrate creation
// and traversal of Header Linked List
#include <bits/stdc++.h>
// #include <malloc.h>
// #include <stdio.h>
// Structure of the list
struct link {
int info;
struct link* next;
};
// Empty List
struct link* start = NULL;
// Function to create header of the
// header linked list
struct link* create_header_list(int data)
{
// Create a new node
struct link *new_node, *node;
new_node = (struct link*)
malloc(sizeof(struct link));
new_node->info = data;
new_node->next = NULL;
// If it is the first node
if (start == NULL) {
// Initialize the start
start = (struct link*)
malloc(sizeof(struct link));
start->next = new_node;
}
else {
// Insert the node in the end
node = start;
while (node->next != NULL) {
node = node->next;
}
node->next = new_node;
}
return start;
}
// Function to display the
// header linked list
struct link* display()
{
struct link* node;
node = start;
node = node->next;
// Traverse until node is
// not NULL
while (node != NULL) {
// Print the data
printf("%d ", node->info);
node = node->next;
}
printf("\n");
// Return the start pointer
return start;
}
// Driver Code
int main()
{
// Create the list
create_header_list(11);
create_header_list(12);
create_header_list(13);
// Print the list
printf("List After inserting"
" 3 elements:\n");
display();
create_header_list(14);
create_header_list(15);
// Print the list
printf("List After inserting"
" 2 more elements:\n");
display();
return 0;
}
Java
// Java program to illustrate creation
// and traversal of Header Linked List
class GFG{
// Structure of the list
static class link {
int info;
link next;
};
// Empty List
static link start = null;
// Function to create header of the
// header linked list
static link create_header_list(int data)
{
// Create a new node
link new_node, node;
new_node = new link();
new_node.info = data;
new_node.next = null;
// If it is the first node
if (start == null) {
// Initialize the start
start = new link();
start.next = new_node;
}
else {
// Insert the node in the end
node = start;
while (node.next != null) {
node = node.next;
}
node.next = new_node;
}
return start;
}
// Function to display the
// header linked list
static link display()
{
link node;
node = start;
node = node.next;
// Traverse until node is
// not null
while (node != null) {
// Print the data
System.out.printf("%d ", node.info);
node = node.next;
}
System.out.printf("\n");
// Return the start pointer
return start;
}
// Driver Code
public static void main(String[] args)
{
// Create the list
create_header_list(11);
create_header_list(12);
create_header_list(13);
// Print the list
System.out.printf("List After inserting"
+ " 3 elements:\n");
display();
create_header_list(14);
create_header_list(15);
// Print the list
System.out.printf("List After inserting"
+ " 2 more elements:\n");
display();
}
}
// This code is contributed by 29AjayKumar
Python3
# structure of Node class Node: def __init__(self, data): self.data = data self.next = None class LinkedList: def __init__(self): self.head = Node(0) self.last_node = self.head # function to add elements to header linked list def append(self, data): self.last_node.next = Node(data) self.last_node = self.last_node.next # function to print the content of header linked list def display(self): current = self.head.next # traversing the header linked list while current is not None: # at each node printing its data print(current.data, end=' ') # giving current next node current = current.next # print(self.head.data) print() if __name__ == '__main__': L = LinkedList() # adding elements to the header linked list L.append(1) L.append(2) L.append(3) L.append(4) # displaying elements of header linked list L.display()
C#
// C# program to illustrate creation
// and traversal of Header Linked List
using System;
public class GFG{
// Structure of the list
public class link {
public int info;
public link next;
};
// Empty List
static link start = null;
// Function to create header of the
// header linked list
static link create_header_list(int data)
{
// Create a new node
link new_node, node;
new_node = new link();
new_node.info = data;
new_node.next = null;
// If it is the first node
if (start == null) {
// Initialize the start
start = new link();
start.next = new_node;
}
else {
// Insert the node in the end
node = start;
while (node.next != null) {
node = node.next;
}
node.next = new_node;
}
return start;
}
// Function to display the
// header linked list
static link display()
{
link node;
node = start;
node = node.next;
// Traverse until node is
// not null
while (node != null) {
// Print the data
Console.Write("{0} ", node.info);
node = node.next;
}
Console.Write("\n");
// Return the start pointer
return start;
}
// Driver Code
public static void Main(String[] args)
{
// Create the list
create_header_list(11);
create_header_list(12);
create_header_list(13);
// Print the list
Console.Write("List After inserting"
+ " 3 elements:\n");
display();
create_header_list(14);
create_header_list(15);
// Print the list
Console.Write("List After inserting"
+ " 2 more elements:\n");
display();
}
}
// This code is contributed by 29AjayKumar
Producción
List After inserting 3 elements: 11 12 13 List After inserting 2 more elements: 11 12 13 14 15
Publicación traducida automáticamente
Artículo escrito por anuragtarang60 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA