smallmouse158
New member
## Sắp xếp hợp nhất trong C ++
Sắp xếp hợp nhất là một thuật toán sắp xếp hoạt động bằng cách tách một nửa danh sách một nửa cho đến khi mỗi người phụ chứa một phần tử duy nhất.Hai người con được sắp xếp sau đó được hợp nhất với nhau để tạo thành một danh sách được sắp xếp duy nhất.Sắp xếp hợp nhất là một loại so sánh **, có nghĩa là nó chỉ so sánh các yếu tố của danh sách để xác định thứ tự của chúng.Điều này làm cho nó trở thành một loại ** ổn định **, có nghĩa là thứ tự tương đối của các phần tử bằng nhau trong danh sách đầu vào được bảo tồn trong danh sách đầu ra.
Sắp xếp hợp nhất là một thuật toán ** o (n log n) **, có nghĩa là độ phức tạp thời gian của nó tỷ lệ thuận với logarit của kích thước của danh sách.Điều này làm cho nó là một thuật toán sắp xếp ** rất hiệu quả cho các danh sách lớn.
### Pseudocode
Sau đây là mã giả để hợp nhất sắp xếp:
`` `
Hàm Merge_Sort (Danh sách):
# Trường hợp cơ sở: Một danh sách có một hoặc ít phần tử hơn đã được sắp xếp.
Nếu len (danh sách) <= 1:
Danh sách trả lại
# Sắp xếp đệ quy một nửa bên trái và bên phải của danh sách.
mid = len (danh sách) // 2
left = merge_sort (danh sách [: mid])
phải = merge_sort (danh sách [mid:])
# Hợp nhất hai nửa được sắp xếp vào một danh sách được sắp xếp.
hợp nhất = []
Trong khi trái và phải:
Nếu rời khỏi [0] <Phải [0]:
hợp nhất.append (trái.pop (0))
khác:
đã hợp nhất.append (Right.pop (0))
# Thêm bất kỳ phần tử còn lại từ nửa bên trái hoặc bên phải vào danh sách được hợp nhất.
đã hợp nhất.extend (trái)
đã hợp nhất.EXTEND (phải)
trả lại sáp nhập
`` `
### Triển khai trong C ++
Sau đây là việc thực hiện Sắp xếp hợp nhất trong C ++:
`` `C ++
#include <Istream>
#include <Vector>
sử dụng không gian tên STD;
// hợp nhất hai người phụ được sắp xếp thành một danh sách được sắp xếp.
Vector <Int> Merge (Vector <Int> Left, Vector <Int> Right) {
// Tạo một vectơ mới để lưu trữ danh sách hợp nhất.
Vector <Int> sáp nhập;
// Lặp lại bên trái và bên phải, thêm phần tử nhỏ hơn vào danh sách hợp nhất.
while (left.size ()> 0 && right.size ()> 0) {
if (trái [0] <phải [0]) {
hợp nhất.push_back (trái.front ());
trái.erase (trái.begin ());
} khác {
hợp nhất.push_back (right.front ());
phải.erase (phải.begin ());
}
}
// Thêm bất kỳ yếu tố còn lại từ những người phụ bên trái hoặc bên phải vào danh sách hợp nhất.
s sự hợp nhất.insert (sạc.end (), left.begin (), left.end ());
s sự hợp nhất.insert (sạc.end (), right.begin (), right.end ());
trở lại sáp nhập;
}
// Sắp xếp đệ quy một danh sách.
Vector <Int> merge_sort (vector <tint> list) {
// Trường hợp cơ sở: Một danh sách có một hoặc ít phần tử hơn đã được sắp xếp.
if (list.size () <= 1) {
danh sách trả lại;
}
// Sắp xếp đệ quy một nửa bên trái và bên phải của danh sách.
int mid = list.size () // 2;
vector <tint> left = merge_sort (list [: mid]);
vector <int> right = merge_sort (list [mid:]);
// hợp nhất hai nửa được sắp xếp vào một danh sách được sắp xếp.
trả lại hợp nhất (trái, phải);
}
int main () {
// Tạo một danh sách các số nguyên chưa được phân loại.
vector <int> list = {5, 3, 1, 2, 4};
// Sắp xếp danh sách bằng cách sử dụng Merge sắp xếp.
Danh sách = Merge_Sort (Danh sách);
// In danh sách sắp xếp.
for (int i = 0; i <list.size (); i ++) {
cout
=======================================
## Merge Sort in C++
Merge sort is a sorting algorithm that works by recursively splitting a list in half until each sublist contains a single element. The two sorted sublists are then merged together to form a single sorted list. Merge sort is a **comparison sort**, meaning that it only compares the elements of the list to determine their order. This makes it a **stable sort**, meaning that the relative order of equal elements in the input list is preserved in the output list.
Merge sort is an **O(n log n)** algorithm, meaning that its time complexity is proportional to the logarithm of the size of the list. This makes it a **very efficient** sorting algorithm for large lists.
### Pseudocode
The following is the pseudocode for merge sort:
```
function merge_sort(list):
# Base case: a list with one or fewer elements is already sorted.
if len(list) <= 1:
return list
# Recursively sort the left and right halves of the list.
mid = len(list) // 2
left = merge_sort(list[:mid])
right = merge_sort(list[mid:])
# Merge the two sorted halves into a single sorted list.
merged = []
while left and right:
if left[0] < right[0]:
merged.append(left.pop(0))
else:
merged.append(right.pop(0))
# Add any remaining elements from the left or right halves to the merged list.
merged.extend(left)
merged.extend(right)
return merged
```
### Implementation in C++
The following is an implementation of merge sort in C++:
```c++
#include <iostream>
#include <vector>
using namespace std;
// Merge two sorted sublists into a single sorted list.
vector<int> merge(vector<int> left, vector<int> right) {
// Create a new vector to store the merged list.
vector<int> merged;
// Iterate over the left and right sublists, adding the smaller element to the merged list.
while (left.size() > 0 && right.size() > 0) {
if (left[0] < right[0]) {
merged.push_back(left.front());
left.erase(left.begin());
} else {
merged.push_back(right.front());
right.erase(right.begin());
}
}
// Add any remaining elements from the left or right sublists to the merged list.
merged.insert(merged.end(), left.begin(), left.end());
merged.insert(merged.end(), right.begin(), right.end());
return merged;
}
// Recursively sort a list.
vector<int> merge_sort(vector<int> list) {
// Base case: a list with one or fewer elements is already sorted.
if (list.size() <= 1) {
return list;
}
// Recursively sort the left and right halves of the list.
int mid = list.size() // 2;
vector<int> left = merge_sort(list[:mid]);
vector<int> right = merge_sort(list[mid:]);
// Merge the two sorted halves into a single sorted list.
return merge(left, right);
}
int main() {
// Create a list of unsorted integers.
vector<int> list = {5, 3, 1, 2, 4};
// Sort the list using merge sort.
list = merge_sort(list);
// Print the sorted list.
for (int i = 0; i < list.size(); i++) {
cout
Sắp xếp hợp nhất là một thuật toán sắp xếp hoạt động bằng cách tách một nửa danh sách một nửa cho đến khi mỗi người phụ chứa một phần tử duy nhất.Hai người con được sắp xếp sau đó được hợp nhất với nhau để tạo thành một danh sách được sắp xếp duy nhất.Sắp xếp hợp nhất là một loại so sánh **, có nghĩa là nó chỉ so sánh các yếu tố của danh sách để xác định thứ tự của chúng.Điều này làm cho nó trở thành một loại ** ổn định **, có nghĩa là thứ tự tương đối của các phần tử bằng nhau trong danh sách đầu vào được bảo tồn trong danh sách đầu ra.
Sắp xếp hợp nhất là một thuật toán ** o (n log n) **, có nghĩa là độ phức tạp thời gian của nó tỷ lệ thuận với logarit của kích thước của danh sách.Điều này làm cho nó là một thuật toán sắp xếp ** rất hiệu quả cho các danh sách lớn.
### Pseudocode
Sau đây là mã giả để hợp nhất sắp xếp:
`` `
Hàm Merge_Sort (Danh sách):
# Trường hợp cơ sở: Một danh sách có một hoặc ít phần tử hơn đã được sắp xếp.
Nếu len (danh sách) <= 1:
Danh sách trả lại
# Sắp xếp đệ quy một nửa bên trái và bên phải của danh sách.
mid = len (danh sách) // 2
left = merge_sort (danh sách [: mid])
phải = merge_sort (danh sách [mid:])
# Hợp nhất hai nửa được sắp xếp vào một danh sách được sắp xếp.
hợp nhất = []
Trong khi trái và phải:
Nếu rời khỏi [0] <Phải [0]:
hợp nhất.append (trái.pop (0))
khác:
đã hợp nhất.append (Right.pop (0))
# Thêm bất kỳ phần tử còn lại từ nửa bên trái hoặc bên phải vào danh sách được hợp nhất.
đã hợp nhất.extend (trái)
đã hợp nhất.EXTEND (phải)
trả lại sáp nhập
`` `
### Triển khai trong C ++
Sau đây là việc thực hiện Sắp xếp hợp nhất trong C ++:
`` `C ++
#include <Istream>
#include <Vector>
sử dụng không gian tên STD;
// hợp nhất hai người phụ được sắp xếp thành một danh sách được sắp xếp.
Vector <Int> Merge (Vector <Int> Left, Vector <Int> Right) {
// Tạo một vectơ mới để lưu trữ danh sách hợp nhất.
Vector <Int> sáp nhập;
// Lặp lại bên trái và bên phải, thêm phần tử nhỏ hơn vào danh sách hợp nhất.
while (left.size ()> 0 && right.size ()> 0) {
if (trái [0] <phải [0]) {
hợp nhất.push_back (trái.front ());
trái.erase (trái.begin ());
} khác {
hợp nhất.push_back (right.front ());
phải.erase (phải.begin ());
}
}
// Thêm bất kỳ yếu tố còn lại từ những người phụ bên trái hoặc bên phải vào danh sách hợp nhất.
s sự hợp nhất.insert (sạc.end (), left.begin (), left.end ());
s sự hợp nhất.insert (sạc.end (), right.begin (), right.end ());
trở lại sáp nhập;
}
// Sắp xếp đệ quy một danh sách.
Vector <Int> merge_sort (vector <tint> list) {
// Trường hợp cơ sở: Một danh sách có một hoặc ít phần tử hơn đã được sắp xếp.
if (list.size () <= 1) {
danh sách trả lại;
}
// Sắp xếp đệ quy một nửa bên trái và bên phải của danh sách.
int mid = list.size () // 2;
vector <tint> left = merge_sort (list [: mid]);
vector <int> right = merge_sort (list [mid:]);
// hợp nhất hai nửa được sắp xếp vào một danh sách được sắp xếp.
trả lại hợp nhất (trái, phải);
}
int main () {
// Tạo một danh sách các số nguyên chưa được phân loại.
vector <int> list = {5, 3, 1, 2, 4};
// Sắp xếp danh sách bằng cách sử dụng Merge sắp xếp.
Danh sách = Merge_Sort (Danh sách);
// In danh sách sắp xếp.
for (int i = 0; i <list.size (); i ++) {
cout
=======================================
## Merge Sort in C++
Merge sort is a sorting algorithm that works by recursively splitting a list in half until each sublist contains a single element. The two sorted sublists are then merged together to form a single sorted list. Merge sort is a **comparison sort**, meaning that it only compares the elements of the list to determine their order. This makes it a **stable sort**, meaning that the relative order of equal elements in the input list is preserved in the output list.
Merge sort is an **O(n log n)** algorithm, meaning that its time complexity is proportional to the logarithm of the size of the list. This makes it a **very efficient** sorting algorithm for large lists.
### Pseudocode
The following is the pseudocode for merge sort:
```
function merge_sort(list):
# Base case: a list with one or fewer elements is already sorted.
if len(list) <= 1:
return list
# Recursively sort the left and right halves of the list.
mid = len(list) // 2
left = merge_sort(list[:mid])
right = merge_sort(list[mid:])
# Merge the two sorted halves into a single sorted list.
merged = []
while left and right:
if left[0] < right[0]:
merged.append(left.pop(0))
else:
merged.append(right.pop(0))
# Add any remaining elements from the left or right halves to the merged list.
merged.extend(left)
merged.extend(right)
return merged
```
### Implementation in C++
The following is an implementation of merge sort in C++:
```c++
#include <iostream>
#include <vector>
using namespace std;
// Merge two sorted sublists into a single sorted list.
vector<int> merge(vector<int> left, vector<int> right) {
// Create a new vector to store the merged list.
vector<int> merged;
// Iterate over the left and right sublists, adding the smaller element to the merged list.
while (left.size() > 0 && right.size() > 0) {
if (left[0] < right[0]) {
merged.push_back(left.front());
left.erase(left.begin());
} else {
merged.push_back(right.front());
right.erase(right.begin());
}
}
// Add any remaining elements from the left or right sublists to the merged list.
merged.insert(merged.end(), left.begin(), left.end());
merged.insert(merged.end(), right.begin(), right.end());
return merged;
}
// Recursively sort a list.
vector<int> merge_sort(vector<int> list) {
// Base case: a list with one or fewer elements is already sorted.
if (list.size() <= 1) {
return list;
}
// Recursively sort the left and right halves of the list.
int mid = list.size() // 2;
vector<int> left = merge_sort(list[:mid]);
vector<int> right = merge_sort(list[mid:]);
// Merge the two sorted halves into a single sorted list.
return merge(left, right);
}
int main() {
// Create a list of unsorted integers.
vector<int> list = {5, 3, 1, 2, 4};
// Sort the list using merge sort.
list = merge_sort(list);
// Print the sorted list.
for (int i = 0; i < list.size(); i++) {
cout
