Constructor de copias de C++ para listas enlazadas individualmente

1. Estructura de datos de lista enlazada de C++
2. Código de ejemplo de una lista enlazada individualmente
3. C++ Copiar constructor de una lista enlazada individualmente

Este artículo discutirá primero el concepto de una estructura de datos de lista enlazada y los escenarios adecuados para usarla. Luego, discutiremos una implementación compacta para la lista individual y el constructor de copias de la lista vinculada individual usando C++.

Estructura de datos de lista enlazada de C++

La principal ventaja de una estructura de datos de lista enlazada es su capacidad para almacenar datos en ubicaciones de memoria no contiguas. Es una estructura de datos lineal que consta de nodos, donde cada nodo almacena el elemento de datos (datos de satélite clave y relacionados) y una referencia al siguiente nodo.

Un puntero principal apunta al primer nodo en esta estructura de datos; por lo tanto, a veces se le llama nodo principal. Algunas implementaciones clásicas de las listas de enlaces simples también tienen un puntero de cola que apunta al último nodo de la lista.

Por ejemplo, la siguiente figura muestra una representación de ejemplo de un concepto de lista enlazada sin un puntero de cola.

La Lista Enlazada tiene tres tipos:

1. Lista de enlaces simples o lista de enlaces simples

   Es una Lista Enlazada simple, también llamada Lista Enlazada Individualmente, en la que solo podemos avanzar. Cada nodo almacena el elemento de datos y la referencia del siguiente nodo.

2. Lista doblemente enlazada

   Es una Lista Enlazada en la que podemos avanzar y retroceder. Cada nodo de la Lista de enlaces dobles consta del elemento de datos, la referencia del siguiente nodo y la referencia del nodo anterior.

   Se adapta al bateador en escenarios de estados de hacer/rehacer, incluida la página siguiente de los navegadores web y las navegaciones anteriores.

3. Lista enlazada circular

   Es casi lo mismo que una lista enlazada individualmente, excepto que el siguiente puntero en el último nodo de la lista siempre apunta al primer nodo. Esto crea un círculo; por lo tanto, se llama Lista Circular Vinculada.

   Suele ser útil en los sistemas de gestión de colas circulares.

Código de ejemplo de una lista enlazada individualmente

Veamos la siguiente implementación en C++ de una lista enlazada individualmente:

#include <iostream>
using namespace std;

class Node {
 public:
  int data;
  Node* next;
};
class LinkedList {
 public:
  Node* head;

  LinkedList() { head = nullptr; }
  void addNewItem(int data) {
    Node* temp = new Node();
    temp->data = data;
    temp->next = head;
    head = temp;
  }
  void display() {
    Node* temp = head;
    while (temp != nullptr) {
      cout << temp->data << ",";
      temp = temp->next;
    }
    cout << endl;
  }
};
int main() {
  LinkedList list;
  list.addNewItem(5);
  list.addNewItem(10);
  list.addNewItem(15);
  list.display();
  return 0;
}

El código anterior consta de las siguientes clases:

1. Una clase Nodo con dos variables miembro: los data y un puntero de clase Nodo siguiente. La variable data se utiliza para almacenar el valor del elemento, y la variable siguiente se utiliza para almacenar la referencia del siguiente elemento.
2. Una clase LinkedList tiene una variable miembro head de tipo Node utilizada para almacenar el primer elemento de la Lista enlazada, un constructor LinkedList(), y dos funciones miembro addNewItem y display(). El constructor LinkedList() inicializa el encabezado con el valor nulo.

El método addNewItem se usa para agregar un nuevo elemento al frente de la lista enlazada. También podemos llamar a esta función AddToFront o push.

El método display() muestra los elementos de la lista enlazada.

C++ Copiar constructor de una lista enlazada individualmente

El siguiente es el código del constructor de copias de una lista enlazada individualmente.

LinkedList(const LinkedList& obj) {
  if (obj.head != nullptr) {
    this->head = new Node;
    this->head->data = obj.head->data;
    Node* temp = obj.head->next;
    Node* temp2 = this->head;
    while (temp != nullptr) {
      Node* newNode = new Node;    ////
      newNode->data = temp->data;  ////    creating new node
      newNode->next = temp->next;  ////
      temp2->next = newNode;
      temp2 = temp2->next;
      temp = temp->next;
    }
  } else {
    head = nullptr;
  }
}

El código anterior muestra el constructor de copia de Lista enlazada individual, que acepta un objeto de lista enlazada const LinkedList &obj como parámetro y copia todos los datos de la Lista enlazada recibida a la Lista enlazada llamante.

Como la Lista Enlazada usa el puntero de tipo Nodo, debemos definir el constructor de copia para la copia profunda. Se creará una copia superficial si no se proporciona la implementación para el constructor de copias.

Llamando al constructor de copias

Considere el siguiente código de la función main():

int main() {
  LinkedList list;  // Declaring a List
  list.addNewItem(5);
  list.addNewItem(10);
  list.addNewItem(15);
  cout << "The content of List 1 are: ";
  list.display();

  LinkedList list2(list);  // Declaring a list2 with the copy constructor
  cout << "The content of List 2 are: ";
  list2.display();
  return 0;
}

En el código anterior, se crea una lista de objetos de tipo LinkedList usando la lista LinkedList; declaración. Después de esto, insertamos tres valores en la lista usando el método list.addNewItem( ).

Se crea otro objeto de list2 de tipo LinkedList, y pasamos el primer objeto list como parámetro en el momento de la declaración para llamar al constructor de copias. El método display() de ambos objetos muestra los mismos elementos de datos en la lista.

Producción: