vietngocbass
New member
#C ++, danh sách #Linked, #Reverse, #data Cấu trúc
## Đảo ngược danh sách được liên kết trong 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ử trong danh sách để phần tử cuối cùng trở thành phần tử đầu tiên, v.v.
Đảo ngược một danh sách được liên kết là một nhiệm vụ tương đối đơn giản, nhưng có thể khó khăn để có được logic đúng.Trong hướng dẫn này, chúng tôi sẽ chỉ cho bạn cách đảo ngược danh sách được liên kết trong C ++ bằng hai phương pháp khác nhau:
*** Phương pháp lặp **
*** Phương pháp đệ quy **
### Phương pháp lặp
Phương pháp lặp là một cách đơ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, chúng tôi trao đổi nút hiện tại với nút tiếp theo.
Đây là mã giả cho phương pháp lặp:
`` `
#include <Istream>
sử dụng không gian tên STD;
Nút cấu trúc {
dữ liệu int;
Nút* tiếp theo;
};
Nút* ReverseLinkedList (nút* đầu) {
// Tạo một nút mới sẽ trỏ đến phần tử cuối cùng trong danh sách đảo ngược.
Nút* lastNode = null;
// Lặp qua danh sách, hoán đổi từng nút với nút tiếp theo.
for (nút* currentNode = head; currentNode! = null; currentNode = currentNode-> next) {
// Lưu nút tiếp theo để chúng tôi có thể liên kết nó với nút cuối cùng sau đó.
Nút* nextNode = currentNode-> next;
// Trao đổi nút hiện tại với nút tiếp theo.
currentNode-> next = lastNode;
// Cập nhật nút cuối cùng.
lastNode = currentNode;
}
// Trả về nút cuối cùng, hiện là người đứng đầu danh sách đảo ngược.
trả về LastNode;
}
int main () {
// Tạo một danh sách được liên kết.
Nút* head = node node ();
đầu-> data = 1;
Nút* node1 = new node ();
node1-> data = 2;
đầu-> next = node1;
Nút* node2 = new node ();
node2-> data = 3;
node1-> next = node2;
// In danh sách ban đầu.
cout << "Danh sách gốc:";
for (nút* currentNode = head; currentNode! = null; currentNode = currentNode-> next) {
cout << currentNode-> data << "";
}
cout << endl;
// đảo ngược danh sách.
Nút* Reversedhead = ReverseLinkedList (đầu);
// In danh sách đảo ngược.
cout << "Danh sách đảo ngược:";
for (nút* currentNode = respressEdhead; currentNode! = null; currentNode = currentNode-> next) {
cout << currentNode-> data << "";
}
cout << endl;
trả lại 0;
}
`` `
### Phương pháp đệ quy
Phương pháp đệ quy là một cách hiệu quả hơn để đảo ngược danh sách được liên kết.Nó hoạt động bằng cách tự gọi mình trên nút tiếp theo, và sau đó đổi nút hiện tại với đầu của danh sách đảo ngược.
Đây là mã giả cho phương pháp đệ quy:
`` `
#include <Istream>
sử dụng không gian tên STD;
Nút cấu trúc {
dữ liệu int;
Nút* tiếp theo;
};
Nút* ReverseLinkedList (nút* đầu) {
// Nếu danh sách trống, hãy trả lại null.
if (head == null) {
trả lại null;
}
// đệ quy đảo ngược phần còn lại của danh sách.
Nút* ReversedList = ReverselinkedList (đầu-> tiếp theo);
// Trao đổi nút hiện tại với đầu của danh sách đảo ngược.
đầu-> tiếp theo = Danh sách đảo ngược;
// Trả về nút hiện tại, hiện là người đứng đầu danh sách đảo ngược.
trở lại đầu;
}
int main () {
// Tạo nên
=======================================
#C++, #Linked List, #Reverse, #data Structure
## Reverse a Linked List in C++
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 in the list so that the last element becomes the first element, and so on.
Reversing a linked list is a relatively simple task, but it can be tricky to get the logic right. In this tutorial, we will show you how to reverse a linked list in C++ using two different methods:
* **Iterative method**
* **Recursive method**
### Iterative method
The iterative method is a straightforward way to reverse a linked list. It works by traversing the list from the head to the tail, and at each step, we swap the current node with the next node.
Here is the pseudocode for the iterative method:
```
#include <iostream>
using namespace std;
struct Node {
int data;
Node* next;
};
Node* reverseLinkedList(Node* head) {
// Create a new node that will point to the last element in the reversed list.
Node* lastNode = NULL;
// Iterate through the list, swapping each node with the next node.
for (Node* currentNode = head; currentNode != NULL; currentNode = currentNode->next) {
// Save the next node so that we can link it to the last node later.
Node* nextNode = currentNode->next;
// Swap the current node with the next node.
currentNode->next = lastNode;
// Update the last node.
lastNode = currentNode;
}
// Return the last node, which is now the head of the reversed list.
return lastNode;
}
int main() {
// Create a linked list.
Node* head = new Node();
head->data = 1;
Node* node1 = new Node();
node1->data = 2;
head->next = node1;
Node* node2 = new Node();
node2->data = 3;
node1->next = node2;
// Print the original list.
cout << "Original list: ";
for (Node* currentNode = head; currentNode != NULL; currentNode = currentNode->next) {
cout << currentNode->data << " ";
}
cout << endl;
// Reverse the list.
Node* reversedHead = reverseLinkedList(head);
// Print the reversed list.
cout << "Reversed list: ";
for (Node* currentNode = reversedHead; currentNode != NULL; currentNode = currentNode->next) {
cout << currentNode->data << " ";
}
cout << endl;
return 0;
}
```
### Recursive method
The recursive method is a more efficient way to reverse a linked list. It works by recursively calling itself on the next node, and then swapping the current node with the head of the reversed list.
Here is the pseudocode for the recursive method:
```
#include <iostream>
using namespace std;
struct Node {
int data;
Node* next;
};
Node* reverseLinkedList(Node* head) {
// If the list is empty, return NULL.
if (head == NULL) {
return NULL;
}
// Recursively reverse the rest of the list.
Node* reversedList = reverseLinkedList(head->next);
// Swap the current node with the head of the reversed list.
head->next = reversedList;
// Return the current node, which is now the head of the reversed list.
return head;
}
int main() {
// Create
## Đảo ngược danh sách được liên kết trong 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ử trong danh sách để phần tử cuối cùng trở thành phần tử đầu tiên, v.v.
Đảo ngược một danh sách được liên kết là một nhiệm vụ tương đối đơn giản, nhưng có thể khó khăn để có được logic đúng.Trong hướng dẫn này, chúng tôi sẽ chỉ cho bạn cách đảo ngược danh sách được liên kết trong C ++ bằng hai phương pháp khác nhau:
*** Phương pháp lặp **
*** Phương pháp đệ quy **
### Phương pháp lặp
Phương pháp lặp là một cách đơ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, chúng tôi trao đổi nút hiện tại với nút tiếp theo.
Đây là mã giả cho phương pháp lặp:
`` `
#include <Istream>
sử dụng không gian tên STD;
Nút cấu trúc {
dữ liệu int;
Nút* tiếp theo;
};
Nút* ReverseLinkedList (nút* đầu) {
// Tạo một nút mới sẽ trỏ đến phần tử cuối cùng trong danh sách đảo ngược.
Nút* lastNode = null;
// Lặp qua danh sách, hoán đổi từng nút với nút tiếp theo.
for (nút* currentNode = head; currentNode! = null; currentNode = currentNode-> next) {
// Lưu nút tiếp theo để chúng tôi có thể liên kết nó với nút cuối cùng sau đó.
Nút* nextNode = currentNode-> next;
// Trao đổi nút hiện tại với nút tiếp theo.
currentNode-> next = lastNode;
// Cập nhật nút cuối cùng.
lastNode = currentNode;
}
// Trả về nút cuối cùng, hiện là người đứng đầu danh sách đảo ngược.
trả về LastNode;
}
int main () {
// Tạo một danh sách được liên kết.
Nút* head = node node ();
đầu-> data = 1;
Nút* node1 = new node ();
node1-> data = 2;
đầu-> next = node1;
Nút* node2 = new node ();
node2-> data = 3;
node1-> next = node2;
// In danh sách ban đầu.
cout << "Danh sách gốc:";
for (nút* currentNode = head; currentNode! = null; currentNode = currentNode-> next) {
cout << currentNode-> data << "";
}
cout << endl;
// đảo ngược danh sách.
Nút* Reversedhead = ReverseLinkedList (đầu);
// In danh sách đảo ngược.
cout << "Danh sách đảo ngược:";
for (nút* currentNode = respressEdhead; currentNode! = null; currentNode = currentNode-> next) {
cout << currentNode-> data << "";
}
cout << endl;
trả lại 0;
}
`` `
### Phương pháp đệ quy
Phương pháp đệ quy là một cách hiệu quả hơn để đảo ngược danh sách được liên kết.Nó hoạt động bằng cách tự gọi mình trên nút tiếp theo, và sau đó đổi nút hiện tại với đầu của danh sách đảo ngược.
Đây là mã giả cho phương pháp đệ quy:
`` `
#include <Istream>
sử dụng không gian tên STD;
Nút cấu trúc {
dữ liệu int;
Nút* tiếp theo;
};
Nút* ReverseLinkedList (nút* đầu) {
// Nếu danh sách trống, hãy trả lại null.
if (head == null) {
trả lại null;
}
// đệ quy đảo ngược phần còn lại của danh sách.
Nút* ReversedList = ReverselinkedList (đầu-> tiếp theo);
// Trao đổi nút hiện tại với đầu của danh sách đảo ngược.
đầu-> tiếp theo = Danh sách đảo ngược;
// Trả về nút hiện tại, hiện là người đứng đầu danh sách đảo ngược.
trở lại đầu;
}
int main () {
// Tạo nên
=======================================
#C++, #Linked List, #Reverse, #data Structure
## Reverse a Linked List in C++
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 in the list so that the last element becomes the first element, and so on.
Reversing a linked list is a relatively simple task, but it can be tricky to get the logic right. In this tutorial, we will show you how to reverse a linked list in C++ using two different methods:
* **Iterative method**
* **Recursive method**
### Iterative method
The iterative method is a straightforward way to reverse a linked list. It works by traversing the list from the head to the tail, and at each step, we swap the current node with the next node.
Here is the pseudocode for the iterative method:
```
#include <iostream>
using namespace std;
struct Node {
int data;
Node* next;
};
Node* reverseLinkedList(Node* head) {
// Create a new node that will point to the last element in the reversed list.
Node* lastNode = NULL;
// Iterate through the list, swapping each node with the next node.
for (Node* currentNode = head; currentNode != NULL; currentNode = currentNode->next) {
// Save the next node so that we can link it to the last node later.
Node* nextNode = currentNode->next;
// Swap the current node with the next node.
currentNode->next = lastNode;
// Update the last node.
lastNode = currentNode;
}
// Return the last node, which is now the head of the reversed list.
return lastNode;
}
int main() {
// Create a linked list.
Node* head = new Node();
head->data = 1;
Node* node1 = new Node();
node1->data = 2;
head->next = node1;
Node* node2 = new Node();
node2->data = 3;
node1->next = node2;
// Print the original list.
cout << "Original list: ";
for (Node* currentNode = head; currentNode != NULL; currentNode = currentNode->next) {
cout << currentNode->data << " ";
}
cout << endl;
// Reverse the list.
Node* reversedHead = reverseLinkedList(head);
// Print the reversed list.
cout << "Reversed list: ";
for (Node* currentNode = reversedHead; currentNode != NULL; currentNode = currentNode->next) {
cout << currentNode->data << " ";
}
cout << endl;
return 0;
}
```
### Recursive method
The recursive method is a more efficient way to reverse a linked list. It works by recursively calling itself on the next node, and then swapping the current node with the head of the reversed list.
Here is the pseudocode for the recursive method:
```
#include <iostream>
using namespace std;
struct Node {
int data;
Node* next;
};
Node* reverseLinkedList(Node* head) {
// If the list is empty, return NULL.
if (head == NULL) {
return NULL;
}
// Recursively reverse the rest of the list.
Node* reversedList = reverseLinkedList(head->next);
// Swap the current node with the head of the reversed list.
head->next = reversedList;
// Return the current node, which is now the head of the reversed list.
return head;
}
int main() {
// Create
