Share c++ queue source code

[hongphuongphamkha]

## C ++ Mã nguồn hàng

[Liên kết đến bài viết tham khảo]

Hàng đợi là một cấu trúc dữ liệu tuyến tính trong đó các phần tử được thêm vào một đầu, được gọi là phía sau và được loại bỏ khỏi đầu kia, được gọi là mặt trước.Hàng đợi thường được sử dụng để triển khai danh sách chờ hoặc để lưu trữ dữ liệu sẽ được xử lý theo thứ tự đầu tiên, đầu tiên (FIFO).

Trong C ++, một hàng đợi có thể được triển khai bằng danh sách được liên kết hoặc một mảng động.Việc triển khai danh sách được liên kết hiệu quả hơn đối với hàng đợi có khả năng phát triển và co lại thường xuyên, trong khi việc triển khai mảng động hiệu quả hơn đối với hàng đợi có khả năng vẫn có cùng kích thước trong thời gian dài.

Mã sau đây cho thấy cách thực hiện hàng đợi bằng danh sách được liên kết 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 hàng đợi được triển khai bằng danh sách được liên kết
Lớp xếp hàng {
riêng tư:
// Đầu của hàng đợi
Nút* đầu;

// đuôi của hàng đợi
Nút* đuôi;

công cộng:
// Tạo một hàng đợi mới
Xếp hàng() {
đầu = null;
đuôi = null;
}

// Thêm một phần tử vào hàng đợi
void enqueue (data int) {
// Tạo một nút mới
Nút* newNode = new node ();

// Đặt dữ liệu của nút
newnode-> data = data;

// Đặt con trỏ tiếp theo của nút thành NULL
newnode-> next = null;

// Nếu hàng đợi trống, hãy đặt đầu và đuôi vào nút mới
if (head == null) {
đầu = newNode;
đuôi = newnode;
} khác {
// Nếu không, hãy thêm nút mới vào cuối hàng đợi
đuôi-> next = newNode;
đuôi = newnode;
}
}

// Xóa một phần tử khỏi hàng đợi
int dequeue () {
// Nếu hàng đợi trống, hãy trả lại -1
if (head == null) {
trả lại -1;
}

// Nhận dữ liệu từ nút đầu
int data = head-> data;

// Đặt con trỏ đầu sang nút tiếp theo
đầu = đầu-> tiếp theo;

// Nếu hàng đợi bây giờ trống, hãy đặt con trỏ đuôi thành NULL
if (head == null) {
đuôi = null;
}

// trả lại dữ liệu từ nút đầu
trả về dữ liệu;
}

// kiểm tra xem hàng đợi có trống không
bool isempty () {
trả về đầu == null;
}
};

int main () {
// Tạo hàng đợi
Hàng đợi hàng đợi;

// enqueue một số yếu tố
hàng đợi.enqueue (1);
hàng đợi.enqueue (2);
hàng đợi.enqueue (3);

// dequeue một số yếu tố
cout << queue.dequeue () << endl;
cout << queue.dequeue () << endl;
cout << queue.dequeue () << endl;

// kiểm tra xem hàng đợi có trống không
cout << "Là hàng đợi trống?" << Queue.isempty () << endl;

trả lại 0;
}
`` `

## hashtags

* #C ++
* #xếp hàng
* Danh sách #Linked
* #cấu trúc dữ liệu
* #vào trước ra trước
=======================================
## C++ Queue Source Code

[Link to reference article]

A queue is a linear data structure in which elements are added at one end, called the rear, and removed from the other end, called the front. Queues are often used to implement waiting lists or to store data that will be processed in a first-in, first-out (FIFO) order.

In C++, a queue can be implemented using a linked list or a dynamic array. A linked list implementation is more efficient for queues that are likely to grow and shrink frequently, while a dynamic array implementation is more efficient for queues that are likely to remain the same size for long periods of time.

The following code shows how to implement a queue using a linked list in C++:

```c++
#include <iostream>
#include <list>

using namespace std;

// A linked list node
struct Node {
int data;
Node* next;
};

// A queue implemented using a linked list
class Queue {
private:
// The head of the queue
Node* head;

// The tail of the queue
Node* tail;

public:
// Create a new queue
Queue() {
head = NULL;
tail = NULL;
}

// Add an element to the queue
void enqueue(int data) {
// Create a new node
Node* newNode = new Node();

// Set the node's data
newNode->data = data;

// Set the node's next pointer to NULL
newNode->next = NULL;

// If the queue is empty, set the head and tail to the new node
if (head == NULL) {
head = newNode;
tail = newNode;
} else {
// Otherwise, add the new node to the end of the queue
tail->next = newNode;
tail = newNode;
}
}

// Remove an element from the queue
int dequeue() {
// If the queue is empty, return -1
if (head == NULL) {
return -1;
}

// Get the data from the head node
int data = head->data;

// Set the head pointer to the next node
head = head->next;

// If the queue is now empty, set the tail pointer to NULL
if (head == NULL) {
tail = NULL;
}

// Return the data from the head node
return data;
}

// Check if the queue is empty
bool isEmpty() {
return head == NULL;
}
};

int main() {
// Create a queue
Queue queue;

// Enqueue some elements
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);

// Dequeue some elements
cout << queue.dequeue() << endl;
cout << queue.dequeue() << endl;
cout << queue.dequeue() << endl;

// Check if the queue is empty
cout << "Is the queue empty? " << queue.isEmpty() << endl;

return 0;
}
```

## Hashtags

* #C++
* #Queue
* #Linked list
* #data structure
* #First-in first-out