Share c++ quicksort

[xuanninhmypass]

#C ++ #quicksort #Sorting #algorithms #DatSourures ## C ++ QuickSort

Quicksort là một thuật toán sắp xếp thường được sử dụng trong C ++.Nó là một thuật toán phân chia và chinh phục, có nghĩa là nó hoạt động bằng cách chia các mảng đầu vào thành các mảng con nhỏ hơn và nhỏ hơn cho đến khi mỗi mảng con chỉ chứa một phần tử.Các mảng con sau đó được sắp xếp riêng lẻ và hợp nhất lại với nhau để tạo thành mảng đầu ra được sắp xếp.

Quicksort là một thuật toán sắp xếp rất hiệu quả và nó thường nhanh hơn các thuật toán sắp xếp khác như phân loại hợp nhất và sắp xếp đống.Tuy nhiên, nó không phải là một thuật toán sắp xếp ổn định, điều đó có nghĩa là nó không bảo tồn thứ tự ban đầu của các phần tử bằng nhau trong mảng.

Sau đây là mã giả cho QuickSort trong C ++:

`` `C ++
void QuickSort (int mảng [], int low, int cao) {
if (thấp <cao) {
// chọn phần tử xoay vòng.
int pivot = mảng [(thấp + cao) / 2];

// Phân vùng mảng xung quanh phần tử trục.
int i = thấp;
int j = cao;
while (i <= j) {
while (mảng <pivot) {
i ++;
}
while (mảng [j]> pivot) {
J--;
}
if (i <= j) {
// hoán đổi các yếu tố tại các chỉ số i và j.
int temp = mảng ;
mảng = mảng [j];
mảng [j] = temp;

// Tăng i và giảm j.
i ++;
J--;
}
}

// Sắp xếp đệ quy các máng phụ trái và phải.
Quicksort (mảng, thấp, j);
Quicksort (mảng, i, cao);
}
}
`` `

## Ví dụ

Sau đây là một ví dụ về cách sử dụng QuickSort trong C ++ để sắp xếp một mảng số nguyên:

`` `C ++
#include <Istream>

sử dụng không gian tên STD;

int main () {
// Tạo một mảng số nguyên.
int mảng [] = {10, 5, 2, 4, 7, 1, 8, 9, 6, 3};

// Sắp xếp mảng bằng QuickSort.
Quicksort (mảng, 0, sizeof (mảng) / sizeof (int) - 1);

// In mảng được sắp xếp.
for (int i = 0; i <sizeof (mảng) / sizeof (int); i ++) {
cout << mảng << "";
}

cout << endl;

trả lại 0;
}
`` `

## đầu ra

`` `
1 2 3 4 5 6 7 8 9 10
`` `

## hashtags

* #C ++
* #Sắp xếp nhanh chóng
* #Sorting
* #algorithms
* #Cấu trúc dữ liệu
=======================================
#C++ #quicksort #Sorting #algorithms #datastructures ##C++ Quicksort

Quicksort is a sorting algorithm that is often used in C++. It is a divide-and-conquer algorithm, which means that it works by recursively dividing the input array into smaller and smaller sub-arrays until each sub-array contains only one element. The sub-arrays are then sorted individually and merged back together to form the sorted output array.

Quicksort is a very efficient sorting algorithm, and it is often faster than other sorting algorithms such as merge sort and heap sort. However, it is not a stable sorting algorithm, which means that it does not preserve the original order of equal elements in the array.

The following is the pseudocode for quicksort in C++:

```c++
void quicksort(int arr[], int low, int high) {
if (low < high) {
// Choose the pivot element.
int pivot = arr[(low + high) / 2];

// Partition the array around the pivot element.
int i = low;
int j = high;
while (i <= j) {
while (arr < pivot) {
i++;
}
while (arr[j] > pivot) {
j--;
}
if (i <= j) {
// Swap the elements at indices i and j.
int temp = arr;
arr = arr[j];
arr[j] = temp;

// Increment i and decrement j.
i++;
j--;
}
}

// Recursively sort the left and right sub-arrays.
quicksort(arr, low, j);
quicksort(arr, i, high);
}
}
```

## Example

The following is an example of how to use quicksort in C++ to sort an array of integers:

```c++
#include <iostream>

using namespace std;

int main() {
// Create an array of integers.
int arr[] = {10, 5, 2, 4, 7, 1, 8, 9, 6, 3};

// Sort the array using quicksort.
quicksort(arr, 0, sizeof(arr) / sizeof(int) - 1);

// Print the sorted array.
for (int i = 0; i < sizeof(arr) / sizeof(int); i++) {
cout << arr << " ";
}

cout << endl;

return 0;
}
```

## Output

```
1 2 3 4 5 6 7 8 9 10
```

## Hashtags

* #C++
* #quicksort
* #Sorting
* #algorithms
* #datastructures