C++-Kopierkonstruktor für einfach verkettete Liste

1. C++ Linked-List-Datenstruktur
2. Beispielcode einer einfach verketteten Liste
3. C++-Kopierkonstruktor einer einfach verketteten Liste

In diesem Artikel werden zunächst das Konzept einer Datenstruktur einer verknüpften Liste und geeignete Szenarien für deren Verwendung erörtert. Dann besprechen wir eine kompakte Implementierung für die einfach verkettete Liste und den Kopierkonstruktor der einfach verketteten Liste mit C++.

C++ Linked-List-Datenstruktur

Der Hauptvorteil einer Linked-List-Datenstruktur ist ihre Fähigkeit, Daten in nicht zusammenhängenden Speicherorten zu speichern. Es handelt sich um eine lineare Datenstruktur, die aus Knoten besteht, wobei jeder Knoten das Datenelement (Schlüssel und zugehörige Satellitendaten) und einen Verweis auf den nächsten Knoten speichert.

Ein Kopfzeiger zeigt auf den ersten Knoten in dieser Datenstruktur; daher wird er manchmal als Kopfknoten bezeichnet. Einige klassische Implementierungen der einfach verknüpften Listen haben auch einen Schwanzzeiger, der auf den letzten Knoten der Liste zeigt.

Die folgende Abbildung zeigt beispielsweise eine beispielhafte Darstellung eines Linked-List-Konzepts ohne Endzeiger.

Die verknüpfte Liste hat drei Typen:

1. Einfach verkettete Liste oder einfache verkettete Liste

   Es ist eine einfache verkettete Liste, auch einfach verkettete Liste genannt, in der wir uns nur vorwärts bewegen können. Jeder Knoten speichert das Datenelement und die Referenz des nächsten Knotens.

2. Doppelt verkettete Liste

   Es ist eine verknüpfte Liste, in der wir uns vorwärts und rückwärts bewegen können. Jeder Knoten der doppelt verknüpften Liste besteht aus dem Datenelement, der Referenz des nächsten Knotens und der Referenz des vorherigen Knotens.

   Es eignet sich für Do/Redo-Zustandsszenarien, einschließlich der nächsten Seite von Webbrowsern und vorherigen Navigationen.

3. Zirkulär verkettete Liste

   Es ist fast dasselbe wie eine einfach verkettete Liste, außer dass der nächste Zeiger im letzten Knoten der Liste immer auf den ersten Knoten zeigt. Dadurch entsteht ein Kreis; daher wird sie als zirkulär verkettete Liste bezeichnet.

   Es ist normalerweise praktisch in kreisförmigen Warteschlangenverwaltungssystemen.

Beispielcode einer einfach verketteten Liste

Schauen wir uns die folgende C++-Implementierung einer einfach verketteten Liste an:

#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;
}

Der obige Code besteht aus den folgenden Klassen:

1. Eine Klasse Node mit zwei Member-Variablen: den data und einem Node-Klassenzeiger next. Die Variable data wird verwendet, um den Wert des Elements zu speichern, und die Variable next wird verwendet, um die Referenz des nächsten Elements zu speichern.
2. Eine Klasse LinkedList hat eine Member-Variable head vom Typ Node, die verwendet wird, um das erste Element der Linked List zu speichern, einen Konstruktor LinkedList() und zwei Member-Funktionen addNewItem und display(). Der Konstruktor LinkedList() initialisiert den Kopf mit dem Nullwert.

Die Methode addNewItem wird verwendet, um ein neues Element am Anfang der Linked List hinzuzufügen. Wir können diese Funktion auch AddToFront oder push nennen.

Die Methode display() zeigt die Elemente der verknüpften Liste an.

C++-Kopierkonstruktor einer einfach verketteten Liste

Das Folgende ist der Code des Kopierkonstruktors einer einfach verketteten Liste.

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;
  }
}

Der obige Code zeigt den Kopierkonstruktor für einfach verknüpfte Listen, der ein verknüpftes Listenobjekt const LinkedList &obj als Parameter akzeptiert und alle Daten aus der empfangenen verknüpften Liste in die aufrufende verknüpfte Liste kopiert.

Da die verknüpfte Liste den Zeiger vom Typ Knoten verwendet, müssen wir den Kopierkonstruktor für die tiefe Kopie definieren. Eine flache Kopie wird erstellt, wenn die Implementierung für den Kopierkonstruktor nicht bereitgestellt wird.

Aufrufen des Kopierkonstruktors

Betrachten Sie den folgenden Code der Funktion 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;
}

Im obigen Code wird ein Objekt Liste vom Typ LinkedList mithilfe der LinkedList-Liste erstellt. Stellungnahme. Danach haben wir mit der Methode list.addNewItem( ) drei Werte in die Liste eingefügt.

Ein weiteres Objekt von list2 vom Typ LinkedList wird erstellt, und wir haben das erste list-Objekt zum Zeitpunkt der Deklaration als Parameter übergeben, um den Kopierkonstruktor aufzurufen. Die Methode display() beider Objekte zeigt dieselben Datenelemente in der Liste.

Ausgang: