phamvywhatwhat
New member
#C ++ #Reverse #C ++ Chuỗi #C ++ Thuật toán #DatSource ### Đảo ngược danh sách liên kết C ++
Danh sách được liên kết là cấu trúc dữ liệu tuyến tính trong đó mỗi phần tử được kết nối với phần tử tiếp theo bằng một con trỏ.Đảo ngược một danh sách được liên kết có nghĩa là thay đổi thứ tự của các phần tử để phần tử cuối cùng trở thành phần tử đầu tiên, v.v.
Có hai cách chính để đảo ngược một danh sách được liên kết trong C ++: lặp đi lặp lại và đệ quy.
#### Đảo ngược lặp lại
Cách tiếp cận lặp là một cách đơn giản và đơn giản để đảo ngược một danh sách được liên kết.Nó hoạt động bằng cách đi qua danh sách từ đầu đến đuôi và ở mỗi bước, hoán đổi con trỏ tiếp theo của nút hiện tại với con trỏ tiếp theo của nút tiếp theo.
Mã sau đây cho thấy cách đảo ngược danh sách được liên kết lặp đi lặp lại trong C ++:
`` `C ++
#include <Istream>
#include <Bart>
sử dụng không gian tên STD;
// Nút danh sách được liên kết
Nút cấu trúc {
dữ liệu int;
Nút* tiếp theo;
};
// một chức năng để đảo ngược danh sách được liên kết lặp đi lặp lại
void Reverselist (Node* Head) {
// Tạo một nút tạm thời để lưu trữ con trỏ tiếp theo của nút hiện tại
Nút* temp;
// đi qua danh sách từ đầu đến đuôi
while (head! = nullptr) {
// Lưu con trỏ tiếp theo của nút hiện tại
temp = head-> tiếp theo;
// Đặt con trỏ tiếp theo của nút hiện tại để trỏ đến nút trước đó
đầu-> next = head-> prev;
// di chuyển nút hiện tại sang nút tiếp theo
đầu = temp;
}
}
// một chức năng để in danh sách được liên kết
void printList (nút* đầu) {
// Tạo một nút tạm thời để đi qua danh sách
Nút* temp = đầu;
// đi qua danh sách và in dữ liệu của từng nút
while (temp! = nullptr) {
cout << Temp-> Dữ liệu << "";
TEMP = TEMP-> Tiếp theo;
}
cout << endl;
}
int main () {
// Tạo một danh sách được liên kết
Nút* head = node node ();
đầu-> data = 1;
Nút* thứ hai = nút new ();
thứ hai-> data = 2;
đầu-> tiếp theo = thứ hai;
Nút* thứ ba = node node ();
Thứ ba-> Dữ liệu = 3;
thứ hai-> tiếp theo = thứ ba;
// In danh sách liên kết ban đầu
cout << "Danh sách liên kết gốc:";
Danh sách in (đầu);
// đảo ngược danh sách được liên kết
Reverselist (đầu);
// In danh sách liên kết đảo ngược
cout << "Danh sách liên kết đảo ngược:";
Danh sách in (đầu);
trả lại 0;
}
`` `
#### đảo ngược đệ quy
Cách tiếp cận đệ quy là một cách hiệu quả hơn để đảo ngược danh sách được liên kết so với phương pháp lặp.Nó hoạt động bằng cách gọi một chức năng để đảo ngược danh sách được liên kết từ đầu đến đuôi.
Mã sau đây cho thấy cách đảo ngược danh sách được liên kết đệ quy trong C ++:
`` `C ++
#include <Istream>
#include <Bart>
sử dụng không gian tên STD;
// Nút danh sách được liên kết
Nút cấu trúc {
dữ liệu int;
Nút* tiếp theo;
};
// một chức năng để đảo ngược danh sách được liên kết đệ quy
Node* Reverselist (Node* Head) {
// trường hợp cơ sở: Nếu danh sách trống, hãy trả lại null
if (head == nullptr) {
trả lại nullptr;
}
// đảo ngược đệ quy phần còn lại của danh sách
Nút* rest = Reverselist (head-> next);
// Đặt con trỏ tiếp theo của nút cuối cùng để trỏ vào đầu
rest-> next = head;
// Đặt con trỏ tiếp theo của đầu thành NULL
đầu-> tiếp theo = nullptr;
// Trả lại nút đầu
trở lại đầu;
}
// một chức năng để in danh sách được liên kết
void printlist (đầu nút*)
=======================================
#C++ #Reverse #C++Chain #C++Algorithms #datastructures ### Reverse a C++ linked list
A linked list is a linear data structure in which each element is connected to the next element by a pointer. Reversing a linked list means changing the order of the elements so that the last element becomes the first element, and so on.
There are two main ways to reverse a linked list in C++: iteratively and recursively.
#### Iterative reversal
The iterative approach is a simple and straightforward way to reverse a linked list. It works by traversing the list from the head to the tail, and at each step, swapping the next pointer of the current node with the next pointer of the next node.
The following code shows how to reverse a linked list iteratively in C++:
```c++
#include <iostream>
#include <list>
using namespace std;
// A linked list node
struct Node {
int data;
Node* next;
};
// A function to reverse a linked list iteratively
void reverseList(Node* head) {
// Create a temporary node to store the next pointer of the current node
Node* temp;
// Traverse the list from the head to the tail
while (head != nullptr) {
// Save the next pointer of the current node
temp = head->next;
// Set the next pointer of the current node to point to the previous node
head->next = head->prev;
// Move the current node to the next node
head = temp;
}
}
// A function to print a linked list
void printList(Node* head) {
// Create a temporary node to traverse the list
Node* temp = head;
// Traverse the list and print the data of each node
while (temp != nullptr) {
cout << temp->data << " ";
temp = temp->next;
}
cout << endl;
}
int main() {
// Create a linked list
Node* head = new Node();
head->data = 1;
Node* second = new Node();
second->data = 2;
head->next = second;
Node* third = new Node();
third->data = 3;
second->next = third;
// Print the original linked list
cout << "Original linked list: ";
printList(head);
// Reverse the linked list
reverseList(head);
// Print the reversed linked list
cout << "Reversed linked list: ";
printList(head);
return 0;
}
```
#### Recursive reversal
The recursive approach is a more efficient way to reverse a linked list than the iterative approach. It works by recursively calling a function to reverse the linked list from the head to the tail.
The following code shows how to reverse a linked list recursively in C++:
```c++
#include <iostream>
#include <list>
using namespace std;
// A linked list node
struct Node {
int data;
Node* next;
};
// A function to reverse a linked list recursively
Node* reverseList(Node* head) {
// Base case: if the list is empty, return null
if (head == nullptr) {
return nullptr;
}
// Recursively reverse the rest of the list
Node* rest = reverseList(head->next);
// Set the next pointer of the last node to point to the head
rest->next = head;
// Set the next pointer of the head to null
head->next = nullptr;
// Return the head node
return head;
}
// A function to print a linked list
void printList(Node* head)
Danh sách được liên kết là cấu trúc dữ liệu tuyến tính trong đó mỗi phần tử được kết nối với phần tử tiếp theo bằng một con trỏ.Đảo ngược một danh sách được liên kết có nghĩa là thay đổi thứ tự của các phần tử để phần tử cuối cùng trở thành phần tử đầu tiên, v.v.
Có hai cách chính để đảo ngược một danh sách được liên kết trong C ++: lặp đi lặp lại và đệ quy.
#### Đảo ngược lặp lại
Cách tiếp cận lặp là một cách đơn giản và đơn giản để đảo ngược một danh sách được liên kết.Nó hoạt động bằng cách đi qua danh sách từ đầu đến đuôi và ở mỗi bước, hoán đổi con trỏ tiếp theo của nút hiện tại với con trỏ tiếp theo của nút tiếp theo.
Mã sau đây cho thấy cách đảo ngược danh sách được liên kết lặp đi lặp lại trong C ++:
`` `C ++
#include <Istream>
#include <Bart>
sử dụng không gian tên STD;
// Nút danh sách được liên kết
Nút cấu trúc {
dữ liệu int;
Nút* tiếp theo;
};
// một chức năng để đảo ngược danh sách được liên kết lặp đi lặp lại
void Reverselist (Node* Head) {
// Tạo một nút tạm thời để lưu trữ con trỏ tiếp theo của nút hiện tại
Nút* temp;
// đi qua danh sách từ đầu đến đuôi
while (head! = nullptr) {
// Lưu con trỏ tiếp theo của nút hiện tại
temp = head-> tiếp theo;
// Đặt con trỏ tiếp theo của nút hiện tại để trỏ đến nút trước đó
đầu-> next = head-> prev;
// di chuyển nút hiện tại sang nút tiếp theo
đầu = temp;
}
}
// một chức năng để in danh sách được liên kết
void printList (nút* đầu) {
// Tạo một nút tạm thời để đi qua danh sách
Nút* temp = đầu;
// đi qua danh sách và in dữ liệu của từng nút
while (temp! = nullptr) {
cout << Temp-> Dữ liệu << "";
TEMP = TEMP-> Tiếp theo;
}
cout << endl;
}
int main () {
// Tạo một danh sách được liên kết
Nút* head = node node ();
đầu-> data = 1;
Nút* thứ hai = nút new ();
thứ hai-> data = 2;
đầu-> tiếp theo = thứ hai;
Nút* thứ ba = node node ();
Thứ ba-> Dữ liệu = 3;
thứ hai-> tiếp theo = thứ ba;
// In danh sách liên kết ban đầu
cout << "Danh sách liên kết gốc:";
Danh sách in (đầu);
// đảo ngược danh sách được liên kết
Reverselist (đầu);
// In danh sách liên kết đảo ngược
cout << "Danh sách liên kết đảo ngược:";
Danh sách in (đầu);
trả lại 0;
}
`` `
#### đảo ngược đệ quy
Cách tiếp cận đệ quy là một cách hiệu quả hơn để đảo ngược danh sách được liên kết so với phương pháp lặp.Nó hoạt động bằng cách gọi một chức năng để đảo ngược danh sách được liên kết từ đầu đến đuôi.
Mã sau đây cho thấy cách đảo ngược danh sách được liên kết đệ quy trong C ++:
`` `C ++
#include <Istream>
#include <Bart>
sử dụng không gian tên STD;
// Nút danh sách được liên kết
Nút cấu trúc {
dữ liệu int;
Nút* tiếp theo;
};
// một chức năng để đảo ngược danh sách được liên kết đệ quy
Node* Reverselist (Node* Head) {
// trường hợp cơ sở: Nếu danh sách trống, hãy trả lại null
if (head == nullptr) {
trả lại nullptr;
}
// đảo ngược đệ quy phần còn lại của danh sách
Nút* rest = Reverselist (head-> next);
// Đặt con trỏ tiếp theo của nút cuối cùng để trỏ vào đầu
rest-> next = head;
// Đặt con trỏ tiếp theo của đầu thành NULL
đầu-> tiếp theo = nullptr;
// Trả lại nút đầu
trở lại đầu;
}
// một chức năng để in danh sách được liên kết
void printlist (đầu nút*)
=======================================
#C++ #Reverse #C++Chain #C++Algorithms #datastructures ### Reverse a C++ linked list
A linked list is a linear data structure in which each element is connected to the next element by a pointer. Reversing a linked list means changing the order of the elements so that the last element becomes the first element, and so on.
There are two main ways to reverse a linked list in C++: iteratively and recursively.
#### Iterative reversal
The iterative approach is a simple and straightforward way to reverse a linked list. It works by traversing the list from the head to the tail, and at each step, swapping the next pointer of the current node with the next pointer of the next node.
The following code shows how to reverse a linked list iteratively in C++:
```c++
#include <iostream>
#include <list>
using namespace std;
// A linked list node
struct Node {
int data;
Node* next;
};
// A function to reverse a linked list iteratively
void reverseList(Node* head) {
// Create a temporary node to store the next pointer of the current node
Node* temp;
// Traverse the list from the head to the tail
while (head != nullptr) {
// Save the next pointer of the current node
temp = head->next;
// Set the next pointer of the current node to point to the previous node
head->next = head->prev;
// Move the current node to the next node
head = temp;
}
}
// A function to print a linked list
void printList(Node* head) {
// Create a temporary node to traverse the list
Node* temp = head;
// Traverse the list and print the data of each node
while (temp != nullptr) {
cout << temp->data << " ";
temp = temp->next;
}
cout << endl;
}
int main() {
// Create a linked list
Node* head = new Node();
head->data = 1;
Node* second = new Node();
second->data = 2;
head->next = second;
Node* third = new Node();
third->data = 3;
second->next = third;
// Print the original linked list
cout << "Original linked list: ";
printList(head);
// Reverse the linked list
reverseList(head);
// Print the reversed linked list
cout << "Reversed linked list: ";
printList(head);
return 0;
}
```
#### Recursive reversal
The recursive approach is a more efficient way to reverse a linked list than the iterative approach. It works by recursively calling a function to reverse the linked list from the head to the tail.
The following code shows how to reverse a linked list recursively in C++:
```c++
#include <iostream>
#include <list>
using namespace std;
// A linked list node
struct Node {
int data;
Node* next;
};
// A function to reverse a linked list recursively
Node* reverseList(Node* head) {
// Base case: if the list is empty, return null
if (head == nullptr) {
return nullptr;
}
// Recursively reverse the rest of the list
Node* rest = reverseList(head->next);
// Set the next pointer of the last node to point to the head
rest->next = head;
// Set the next pointer of the head to null
head->next = nullptr;
// Return the head node
return head;
}
// A function to print a linked list
void printList(Node* head)
