#DatSpraf
Danh sách liên kết kép là cấu trúc dữ liệu tuyến tính trong đó mỗi phần tử, được gọi là nút, có một con trỏ tới nút tiếp theo và nút trước đó trong danh sách.Điều này làm cho nó có thể đi qua danh sách theo cả hai hướng, chuyển tiếp và ngược.
Danh sách liên kết kép có tính linh hoạt hơn các danh sách liên kết đơn lẻ vì chúng có thể đi qua cả hai hướng.Điều này có thể hữu ích cho các ứng dụng như tìm kiếm một yếu tố cụ thể trong danh sách hoặc lặp qua danh sách theo thứ tự ngược lại.
Danh sách liên kết kép cũng hiệu quả hơn các danh sách được liên kết đơn để chèn và xóa các yếu tố từ giữa danh sách.Điều này là do, khi chèn hoặc xóa một phần tử khỏi danh sách được liên kết đơn lẻ, con trỏ của tất cả các yếu tố sau khi chèn hoặc điểm xóa cần được cập nhật.Tuy nhiên, khi chèn hoặc xóa một phần tử khỏi danh sách được liên kết kép, chỉ các con trỏ của các phần tử trước và sau khi chèn hoặc xóa cần được cập nhật.
## Cách triển khai danh sách liên kết kép trong C ++
Để thực hiện danh sách liên kết kép trong C ++, bạn có thể sử dụng các bước sau:
1. Xác định lớp `Node`.Lớp `Node` sẽ lưu trữ dữ liệu cho từng phần tử trong danh sách và các gợi ý cho các nút tiếp theo và trước đó.
`` `C ++
Nút lớp {
công cộng:
dữ liệu int;
Nút* tiếp theo;
Nút* trước;
Nút (int dữ liệu) {
this-> data = data;
this-> next = nullptr;
this-> prev = nullptr;
}
};
`` `
2. Xác định lớp `linkedList`.Lớp `LinkedList` sẽ lưu trữ đầu và đuôi của danh sách và cung cấp các phương thức để chèn, xóa và đi qua danh sách.
`` `C ++
Class LinkedList {
công cộng:
Nút* đầu;
Nút* đuôi;
LinkedList () {
this-> head = nullptr;
this-> đuôi = nullptr;
}
void chèn (data int) {
Nút* newnode = node new (dữ liệu);
if (this-> head == nullPtr) {
this-> head = newNode;
this-> đuôi = newNode;
} khác {
newNode-> next = this-> head;
this-> head-> prev = newNode;
this-> head = newNode;
}
}
void Delete (int Data) {
if (this-> head == nullPtr) {
trở lại;
}
Nút* currentNode = this-> head;
while (currentNode! = nullPtr) {
if (currentNode-> data == data) {
if (currentNode == this-> head) {
this-> head = currentNode-> tiếp theo;
}
if (currentNode == this-> đuôi) {
this-> đuôi = currentNode-> prev;
}
if (currentNode-> prev! = nullPtr) {
currentNode-> prev-> next = currentNode-> next;
}
if (currentNode-> next! = nullptr) {
currentNode-> next-> prev = currentNode-> prev;
}
Xóa hiện tạiNode;
trở lại;
}
currentNode = currentNode-> tiếp theo;
}
}
void Traverse () {
Nút* currentNode = this-> head;
while (currentNode! = nullPtr) {
cout << currentNode-> data << endl;
currentNode = currentNode-> tiếp theo;
}
}
};
`` `
##Ví dụ
Mã sau đây hiển thị một ví dụ về cách sử dụng lớp `linkedList` để tạo danh sách liên kết kép và chèn, xóa và đi qua danh sách.
`` `C ++
#include <Istream>
sử dụng không gian tên STD;
Nút lớp {
công cộng:
dữ liệu int;
Nút* tiếp theo;
Nút* trước;
Nút
=======================================
#datastructure #LinkedList #C++ #Programming #tutorial ##Double Linked List in C++
A double linked list is a linear data structure in which each element, called a node, has a pointer to the next node and the previous node in the list. This makes it possible to traverse the list in both directions, forwards and backwards.
Double linked lists are more versatile than singly linked lists because they can be traversed in both directions. This can be useful for applications such as searching for a particular element in the list or iterating over the list in reverse order.
Double linked lists are also more efficient than singly linked lists for inserting and deleting elements from the middle of the list. This is because, when inserting or deleting an element from a singly linked list, the pointers of all the elements after the insertion or deletion point need to be updated. However, when inserting or deleting an element from a double linked list, only the pointers of the elements before and after the insertion or deletion need to be updated.
##How to Implement a Double Linked List in C++
To implement a double linked list in C++, you can use the following steps:
1. Define the `Node` class. The `Node` class will store the data for each element in the list and the pointers to the next and previous nodes.
```c++
class Node {
public:
int data;
Node* next;
Node* prev;
Node(int data) {
this->data = data;
this->next = nullptr;
this->prev = nullptr;
}
};
```
2. Define the `LinkedList` class. The `LinkedList` class will store the head and tail of the list and provide methods for inserting, deleting, and traversing the list.
```c++
class LinkedList {
public:
Node* head;
Node* tail;
LinkedList() {
this->head = nullptr;
this->tail = nullptr;
}
void insert(int data) {
Node* newNode = new Node(data);
if (this->head == nullptr) {
this->head = newNode;
this->tail = newNode;
} else {
newNode->next = this->head;
this->head->prev = newNode;
this->head = newNode;
}
}
void delete(int data) {
if (this->head == nullptr) {
return;
}
Node* currentNode = this->head;
while (currentNode != nullptr) {
if (currentNode->data == data) {
if (currentNode == this->head) {
this->head = currentNode->next;
}
if (currentNode == this->tail) {
this->tail = currentNode->prev;
}
if (currentNode->prev != nullptr) {
currentNode->prev->next = currentNode->next;
}
if (currentNode->next != nullptr) {
currentNode->next->prev = currentNode->prev;
}
delete currentNode;
return;
}
currentNode = currentNode->next;
}
}
void traverse() {
Node* currentNode = this->head;
while (currentNode != nullptr) {
cout << currentNode->data << endl;
currentNode = currentNode->next;
}
}
};
```
##Example
The following code shows an example of how to use the `LinkedList` class to create a double linked list and insert, delete, and traverse the list.
```c++
#include <iostream>
using namespace std;
class Node {
public:
int data;
Node* next;
Node* prev;
Node
Danh sách liên kết kép là cấu trúc dữ liệu tuyến tính trong đó mỗi phần tử, được gọi là nút, có một con trỏ tới nút tiếp theo và nút trước đó trong danh sách.Điều này làm cho nó có thể đi qua danh sách theo cả hai hướng, chuyển tiếp và ngược.
Danh sách liên kết kép có tính linh hoạt hơn các danh sách liên kết đơn lẻ vì chúng có thể đi qua cả hai hướng.Điều này có thể hữu ích cho các ứng dụng như tìm kiếm một yếu tố cụ thể trong danh sách hoặc lặp qua danh sách theo thứ tự ngược lại.
Danh sách liên kết kép cũng hiệu quả hơn các danh sách được liên kết đơn để chèn và xóa các yếu tố từ giữa danh sách.Điều này là do, khi chèn hoặc xóa một phần tử khỏi danh sách được liên kết đơn lẻ, con trỏ của tất cả các yếu tố sau khi chèn hoặc điểm xóa cần được cập nhật.Tuy nhiên, khi chèn hoặc xóa một phần tử khỏi danh sách được liên kết kép, chỉ các con trỏ của các phần tử trước và sau khi chèn hoặc xóa cần được cập nhật.
## Cách triển khai danh sách liên kết kép trong C ++
Để thực hiện danh sách liên kết kép trong C ++, bạn có thể sử dụng các bước sau:
1. Xác định lớp `Node`.Lớp `Node` sẽ lưu trữ dữ liệu cho từng phần tử trong danh sách và các gợi ý cho các nút tiếp theo và trước đó.
`` `C ++
Nút lớp {
công cộng:
dữ liệu int;
Nút* tiếp theo;
Nút* trước;
Nút (int dữ liệu) {
this-> data = data;
this-> next = nullptr;
this-> prev = nullptr;
}
};
`` `
2. Xác định lớp `linkedList`.Lớp `LinkedList` sẽ lưu trữ đầu và đuôi của danh sách và cung cấp các phương thức để chèn, xóa và đi qua danh sách.
`` `C ++
Class LinkedList {
công cộng:
Nút* đầu;
Nút* đuôi;
LinkedList () {
this-> head = nullptr;
this-> đuôi = nullptr;
}
void chèn (data int) {
Nút* newnode = node new (dữ liệu);
if (this-> head == nullPtr) {
this-> head = newNode;
this-> đuôi = newNode;
} khác {
newNode-> next = this-> head;
this-> head-> prev = newNode;
this-> head = newNode;
}
}
void Delete (int Data) {
if (this-> head == nullPtr) {
trở lại;
}
Nút* currentNode = this-> head;
while (currentNode! = nullPtr) {
if (currentNode-> data == data) {
if (currentNode == this-> head) {
this-> head = currentNode-> tiếp theo;
}
if (currentNode == this-> đuôi) {
this-> đuôi = currentNode-> prev;
}
if (currentNode-> prev! = nullPtr) {
currentNode-> prev-> next = currentNode-> next;
}
if (currentNode-> next! = nullptr) {
currentNode-> next-> prev = currentNode-> prev;
}
Xóa hiện tạiNode;
trở lại;
}
currentNode = currentNode-> tiếp theo;
}
}
void Traverse () {
Nút* currentNode = this-> head;
while (currentNode! = nullPtr) {
cout << currentNode-> data << endl;
currentNode = currentNode-> tiếp theo;
}
}
};
`` `
##Ví dụ
Mã sau đây hiển thị một ví dụ về cách sử dụng lớp `linkedList` để tạo danh sách liên kết kép và chèn, xóa và đi qua danh sách.
`` `C ++
#include <Istream>
sử dụng không gian tên STD;
Nút lớp {
công cộng:
dữ liệu int;
Nút* tiếp theo;
Nút* trước;
Nút
=======================================
#datastructure #LinkedList #C++ #Programming #tutorial ##Double Linked List in C++
A double linked list is a linear data structure in which each element, called a node, has a pointer to the next node and the previous node in the list. This makes it possible to traverse the list in both directions, forwards and backwards.
Double linked lists are more versatile than singly linked lists because they can be traversed in both directions. This can be useful for applications such as searching for a particular element in the list or iterating over the list in reverse order.
Double linked lists are also more efficient than singly linked lists for inserting and deleting elements from the middle of the list. This is because, when inserting or deleting an element from a singly linked list, the pointers of all the elements after the insertion or deletion point need to be updated. However, when inserting or deleting an element from a double linked list, only the pointers of the elements before and after the insertion or deletion need to be updated.
##How to Implement a Double Linked List in C++
To implement a double linked list in C++, you can use the following steps:
1. Define the `Node` class. The `Node` class will store the data for each element in the list and the pointers to the next and previous nodes.
```c++
class Node {
public:
int data;
Node* next;
Node* prev;
Node(int data) {
this->data = data;
this->next = nullptr;
this->prev = nullptr;
}
};
```
2. Define the `LinkedList` class. The `LinkedList` class will store the head and tail of the list and provide methods for inserting, deleting, and traversing the list.
```c++
class LinkedList {
public:
Node* head;
Node* tail;
LinkedList() {
this->head = nullptr;
this->tail = nullptr;
}
void insert(int data) {
Node* newNode = new Node(data);
if (this->head == nullptr) {
this->head = newNode;
this->tail = newNode;
} else {
newNode->next = this->head;
this->head->prev = newNode;
this->head = newNode;
}
}
void delete(int data) {
if (this->head == nullptr) {
return;
}
Node* currentNode = this->head;
while (currentNode != nullptr) {
if (currentNode->data == data) {
if (currentNode == this->head) {
this->head = currentNode->next;
}
if (currentNode == this->tail) {
this->tail = currentNode->prev;
}
if (currentNode->prev != nullptr) {
currentNode->prev->next = currentNode->next;
}
if (currentNode->next != nullptr) {
currentNode->next->prev = currentNode->prev;
}
delete currentNode;
return;
}
currentNode = currentNode->next;
}
}
void traverse() {
Node* currentNode = this->head;
while (currentNode != nullptr) {
cout << currentNode->data << endl;
currentNode = currentNode->next;
}
}
};
```
##Example
The following code shows an example of how to use the `LinkedList` class to create a double linked list and insert, delete, and traverse the list.
```c++
#include <iostream>
using namespace std;
class Node {
public:
int data;
Node* next;
Node* prev;
Node
