Kehren Sie jedes Wort im verknüpften Listenknoten um

Eine verknüpfte Liste ist eine lineare Datenstruktur ähnlich einer Kette, in der Elemente nicht wie ein Array nebeneinander im Speicher gespeichert werden. In einer bestimmten verknüpften Liste ist ein Element über einen Zeiger mit dem nächsten Element verbunden. Einfach ausgedrückt ist eine verknüpfte Liste eine Reihe von Datencontainern, in denen wir einen Pfad oder Referenzlink zum nächsten Knoten finden können. In einer verknüpften Liste gibt es als erstes Element einen Kopfzeiger. Wenn der erste Knoten dieser bestimmten verknüpften Liste leer ist, zeigt er auf nichts oder ist leer.

Es gibt verschiedene Arten verknüpfter Listen in Datenstrukturen.

• Einfach verknüpfte Liste - Es handelt sich um einen Grundtyp einer verknüpften Liste in der Datenstruktur, bei der jeder Knoten einige Daten mit einem Zeiger desselben Datentyps für den nächsten Knoten enthält. Hier für diese verknüpfte Liste sowohl die zeitliche Komplexität als auch Hilfsraum ist O(n).

• Doppelt verknüpfte Liste - Es handelt sich um eine komplexe doppelt verknüpfte Liste, die einen Zeiger als Folge vorheriger Knoten enthält. Diese Art von verknüpfter Liste enthält drei verschiedene Teile: die Datenquelle, den Zeiger und den nächsten Knoten. Mit dieser verknüpften Liste können wir die gesamte Liste in umgekehrter Reihenfolge durchlaufen.

• Circular Linked List - In einer zirkulären verknüpften Liste wird der erste Knotenzeiger durch den letzten Knoten der Liste angezeigt. Dies bedeutet, dass die Liste keinen Start- und keinen Endpunkt hat, um eine zirkuläre verknüpfte Liste zu durchlaufen von jedem Knoten aus und durchqueren Sie die Liste nach Wunsch in Vorwärts- oder Rückwärtsrichtung.

• Zwei-Wege-zirkulär verknüpfte Liste – Dies ist eine bidirektional-zirkulär verknüpfte Liste, die Zeiger auf den vorherigen Knoten und den nächsten Knoten enthält. Der vorherige Knoten seines ersten Knotens enthält keinen Nullwert.

In diesem Artikel erstellen wir Code für die oben erwähnte verknüpfte Liste. Mithilfe dieser Codes erfahren wir, wie wir jedes Wort im Knoten der verknüpften Liste in einer C++-Umgebung umkehren.

Algorithmus zum Umkehren jedes in einem verknüpften Listenknoten vorhandenen Wortes

• Schritt 1 – Deklarieren Sie ein temporäres Array.

• Schritt 2 – Durchlaufen einer verknüpften Liste.

• Schritt 3 – Wenn das aktuelle Element ein Alphabet ist, speichern Sie das Element.

• Schritt 4 – Andernfalls erhöhen Sie den Knoten um 1 Zeiger.

• Schritt 5 – Noch einmal vom Kopf aus queren.

• Schritt 6 – Wenn das aktuelle Element ein Alphabet ist, kopieren Sie es in das letzte Element.

• Schritt 7 – Aktuellen Index reduzieren.

• Schritt 8 – Iteration ist ein Muss.

• Schritt 9 – Andernfalls erhöhen Sie den Wert um eins.

Syntax zum Umkehren jedes Wortes in einem verknüpften Listenknoten

insertEnd(head, new_node)
Declare last
   if head == NULL then
      new_node->next = new_node->prev = new_node
      head = new_node
      return
   last = head->prev
   new_node->next = head
   head->prev = new_node
   new_node->prev = last
   last->next = new_node
reverse(head)
   Initialize new_head = NULL
   Declare last
   last = head->prev
   Initialize curr = last, prev
   while curr->prev != last
      prev = curr->prev
      insertEnd(&new_head, curr)
      curr = prev
   insertEnd(&new_head, curr)
return new_head

So folgen Sie:

• Ansatz 1 – Kehren Sie jedes in einer verknüpften Liste vorhandene Wort um

• Ansatz 2 – Kehren Sie den gesamten in einer verknüpften Liste vorhandenen Satz um.

• Ansatz 3 – Umkehren einer doppelt zirkulär verknüpften Liste.

• Ansatz 4 – Eine kreisförmig verknüpfte Liste umkehren.

• Path 5 – Kehren Sie die verknüpfte Liste um, ohne Sonderzeichen zu beeinflussen.

Kehren Sie jedes in einer verknüpften Liste vorhandene Wort mit C++ um

Hier in diesem speziellen C++-Build-Code haben wir jedes in einer verknüpften Liste vorhandene Wort umgekehrt.

Die chinesische Übersetzung von

Beispiel 1

lautet:

Beispiel 1

#include <bits/stdc++.h>
using namespace std;
struct Node {
   string c;
   struct Node* next;
};
struct Node* newNode(string c){
   Node* temp = new Node;
   temp->c = c;
   temp->next = NULL;
   return temp;
};
void reverse_word(string& str){
   reverse(str.begin(), str.end());
}
void reverse(struct Node* head){
   struct Node* ptr = head;
   while (ptr != NULL) {
      reverse_word(ptr->c);
      ptr = ptr->next;
   }
}
void printList(struct Node* head){
   while (head != NULL) {
      cout << head->c << " ";
      head = head->next;
   }
}
int main(){
   Node* head = newNode("Train number 13109");
   head->next = newNode("Maitree Express");
   head->next->next = newNode("is an international train");
   head->next->next->next = newNode("runs between");
   head->next->next->next->next = newNode("Kolkata");
   head->next->next->next->next->next = newNode("and");
   head->next->next->next->next->next->next = newNode("Dhaka");
   cout << "The list here present before reverse: \n";
   printList(head);
   reverse(head);
   cout << "\n\nList after reverse we can see like: \n";
   printList(head);
   return 0;
}

Ausgabe

The list here present before reverse: 
Train number 13109 Maitree Express is an international train runs between Kolkata and Dhaka 

List after reverse we can see like: 
90131 rebmun niarT sserpxE eertiaM niart lanoitanretni na si neewteb snur atakloK dna akahD 

Kehren Sie den gesamten Satz in der verknüpften Liste um

In diesem speziellen Code haben wir den gesamten Satz in der verknüpften Liste umgekehrt.

#include <bits/stdc++.h>
using namespace std;
string reverseString(string str){
   reverse(str.begin(), str.end());
   str.insert(str.end(), ' ');
   int n = str.length();
   int j = 0;
      for (int i = 0; i < n; i++) {
      if (str[i] == ' ') {
         reverse(str.begin() + j,
         str.begin() + i);
         j = i + 1;
      }
   }
   str.pop_back();
   return str;
}
int main(){
   string str = "13110, Maitree Express Is An International Train Runs Between Dhaka And Kolkata";
   string rev = reverseString(str);
   cout << rev;
   return 0;
}

Ausgabe

Kolkata And Dhaka Between Runs Train International An Is Express Maitree 13110,

Eine doppelt zirkulär verknüpfte Liste umkehren

Hier in diesem speziellen Code haben wir eine doppelt zirkulär verknüpfte Liste umgekehrt.

Die chinesische Übersetzung von

Beispiel 3

lautet:

Beispiel 3

#include <bits/stdc++.h><bits stdc++.h="">
using namespace std;
struct Node {
   int data;
   Node *next, *prev;
};
Node* getNode(int data){
   Node* newNode = (Node*)malloc(sizeof(Node));
   newNode->data = data;
   return newNode;
}
void insertEnd(Node** head, Node* new_node) {
   if (*head == NULL) {
      new_node->next = new_node->prev = new_node;
      *head = new_node;
      return;
   }
   Node* last = (*head)->prev;
   new_node->next = *head;
   (*head)->prev = new_node;
   new_node->prev = last;
   last->next = new_node;
}
Node* reverse(Node* head) {
   if (!head)
   return NULL;
   Node* new_head = NULL;
   Node* last = head->prev;
   Node *curr = last, *prev;
   while (curr->prev != last) {
      prev = curr->prev;
      insertEnd(&new_head, curr);
      curr = prev;
   }
   insertEnd(&new_head, curr);
   return new_head;
}
void display(Node* head){
   if (!head)
   return;
   Node* temp = head;
   cout << "Forward direction data source: ";
   while (temp->next != head) {
      cout << temp->data << " ";
      temp = temp->next;
   }
   cout << temp->data;
   Node* last = head->prev;
   temp = last;
   cout << "\nBackward direction data source: ";
   while (temp->prev != last) {
      cout << temp->data << " ";
      temp = temp->prev;
   }
   cout << temp->data;
}
int main(){
   Node* head = NULL;
   insertEnd(&head, getNode(16));
   insertEnd(&head, getNode(10));
   insertEnd(&head, getNode(07));
   insertEnd(&head, getNode(2001));
   insertEnd(&head, getNode(1997));
   cout << "Current list here present:\n";
   display(head);
   head = reverse(head);
   cout << "\n\nReversed list here present:\n";
   display(head);
   return 0;
}
</bits>

Ausgabe

Current list here present:
Forward direction data source: 16 10 7 2001 1997
Backward direction data source: 1997 2001 7 10 16

Reversed list here present:
Forward direction data source: 1997 2001 7 10 16
Backward direction data source: 16 10 7 2001 1997

Umgekehrte zirkuläre verknüpfte Liste

In diesem speziellen Code haben wir einen Datensatz einer zirkulär verknüpften Liste umgekehrt.

Die chinesische Übersetzung von

Beispiel 4

lautet:

Beispiel 4

#include <bits/stdc++.h><bits stdc++.h="">
using namespace std;
struct Node {
   int data;
   Node* next;
};
Node* getNode(int data){
   Node* newNode = new Node;
   newNode->data = data;
   newNode->next = NULL;
   return newNode;
}
void reverse(Node** head_ref){
   if (*head_ref == NULL)
   return;
   Node* prev = NULL;
   Node* current = *head_ref;
   Node* next;
   do {
      next = current->next;
      current->next = prev;
      prev = current;
      current = next;
   } while (current != (*head_ref));
   (*head_ref)->next = prev;
   *head_ref = prev;
}
void printList(Node* head){
   if (head == NULL)
   return;
   Node* temp = head;
   do {
      cout << temp->data << " ";
      temp = temp->next;
   } while (temp != head);
}
int main(){
   Node* head = getNode(10);
   head->next = getNode(16);
   head->next->next = getNode(07);
   head->next->next->next = getNode(2022);
   head->next->next->next->next = head;
   cout << "Given circular linked list is here: ";
   printList(head);
   reverse(&head);
   cout << "\nReversed circular linked list after method: ";
   printList(head);
   return 0;
}
</bits>

Ausgabe

Given circular linked list is here: 10 16 7 2022 
Reversed circular linked list after method: 2022 7 16 10 

Eine verknüpfte Liste umkehren, ohne Sonderzeichen zu beeinflussen

Hier in diesem speziellen Code haben wir den Datensatz der verknüpften Liste umgekehrt, ohne Sonderzeichen zu beeinträchtigen.

Beispiel 5

#include <iostream>
using namespace std;
struct Node {
   char data;
   struct Node* next;
};
void reverse(struct Node** head_ref, int size){
   struct Node* current = *head_ref;
   char TEMP_ARR[size];
   int i = 0;
   while (current != NULL) {
      if ((current->data >= 97 && current->data <= 122) ||
      (current->data >= 65 && current->data <= 90)) {
         TEMP_ARR[i++] = current->data;
         current = current->next;
      }
      else
      current = current->next;
   }
   current = *head_ref;
   while (current != NULL) {
      if ((current->data >= 97 && current->data <= 122) ||
      (current->data >= 65 && current->data <= 90)) {
         current->data = TEMP_ARR[--i];
         current = current->next;
      }
      else
      current = current->next;
   }
}
void push(struct Node** head_ref, char new_data){
   struct Node* new_node = new Node();
   new_node->data = new_data;
   new_node->next = (*head_ref);
   (*head_ref) = new_node;
}
void printList(struct Node* head){
   struct Node* temp = head;
   while (temp != NULL) {
      cout << temp->data;
      temp = temp->next;
   }
}
// Driver program to test above function
int main() {
   struct Node* head = NULL;
   push(&head, 'R');
   push(&head, 'U');
   push(&head, 'D');
   push(&head, 'R');
   push(&head, 'A');
   push(&head, 'K');
   push(&head, 'O');
   push(&head, 'L');
   push(&head, 'K');
   push(&head, 'A');
   push(&head, 'T');
   push(&head, 'A');
   push(&head, '0');
   push(&head, '1');
   push(&head, '0');
   push(&head, '@');
   cout << "Given linked list is here: ";
   printList(head);
   reverse(&head, 13);
   cout << "\nReversed Linked list is here: ";
   printList(head);
   return 0;
}

Ausgabe

Given linked list is here: B@010ATAKLOKARDUR
Reversed Linked list is here: R@010UDRAKOLKATAB

Fazit

In diesem Artikel haben wir gelernt, wie man jedes Wort in einem verknüpften Listenknoten umkehrt. Wir haben hier den C++-Code erstellt, um den möglichen Umkehrprozess zu zeigen, damit Sie ein umfassendes Verständnis der Umkehrung verknüpfter Listenknoten erhalten.

Das obige ist der detaillierte Inhalt vonKehren Sie jedes Wort im verknüpften Listenknoten um. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!