Quick sort là một thuật toán sắp xếp tương đối hiệu quả, phục vụ dựa trên phương pháp để đặt các phần tử trong một mảng [array] theo thứ tự dựa trên một phần tử Key [Pivot]. Là một thuật toán "nâng cấp" của thuật toán sắp xếp Merge Sort.
Thuật toán Quick Sort
Ý tưởng
Quick sort là một trong những thuật toán chia để trị, Quick sort chia một mảng lớn thành 2 mảng con nhỏ hơn:
- Mảng có phần tử nhỏ.
- Mảng có phần tử lớn.
Sau đó Quick sort có thể sort các mảng con bằng phương pháp đệ quy, ý tưởng của Quick sort là:
- Chọn một phần tử để so sánh, gọi là phần tử Key [Pivot], từ trong mảng đầu tiên.
- Phân vùng và sort mảng con trong phân vùng làm sao cho các phần tử lớn hơn từ phần tử Key nằm sau [bên phải] và các phần tử bé hơn phần tử Key nằm trước [bên trái]. Đây được gọi là quá trình phân vùng.
- Cuối cùng là đệ quy sử dụng các bước trên cho các mảng với phần tử bé hơn và phân tách với các phần tử lớn hơn sau khi phân vùng.
Các cách chọn phần tử Key
- Chọn phần tử bên trái ngoài cùng [phần tử đầu tiên của mảng].
- Chọn phần tử bên phải ngoài cùng [phần tử cuối cùng của mảng].
- Ngẫu nhiên một phần tử [sử dụng hàm random mà ngôn ngữ lập trình cung cấp].
- Phần tử chính giữa của mảng [chiều dài của mảng chia đôi].
Code mẫu Quick Sort
// Take Left [first] Index of the array and Right [last] Index of the array void quickSort[int Data[], int l , int r] { // If the first index less or equal than the last index if [l = left && arr[right] > pivot] right–; // tìm phần tử = right] break; // sau khi duyệt xong thì thoát khỏi vòng lặp
swap[arr[left], arr[right]]; // nếu chưa xong thì sử dụng hàm swap[] để tráo đổi.
left++; // Vì left hiện tại đã xét, nên cần tăng
right--; // Vì right hiện tại đã xét, nên cần giảm
}
swap[arr[left], arr[high]];
return left; // Trả về chỉ số sẽ dùng để chia đôi mảng
}
Hàm quicksort[]
void quickSort[int arr[], int low, int high]
{
`{`0
`{`1
/* index là chỉ số nơi phần tử này đã đứng đúng vị trí
và đây là phần tử chia mảng làm 2 mảng con trái & phải */
`{`2
// Gọi đệ quy sắp xếp 2 mảng con trái và phải
`{`3
`{`4
`{`5
`{`6
Hàm swap[]
`{`7
{
`{`9
` int pivot = arr[high]; // `0
` int pivot = arr[high]; // `1
`{`6
Minh họa sắp xếp Quick Sort trong mảng
Để minh họa, ta sẽ thực hiện một ví dụ với việc áp dụng thuật toán sắp xếp nhanh [Quick Sort]. Dưới đây là một mảng cụ thể: arr[] = {9, -3, 5, 2, 6, 8, -6, 1, 3} và được sắp xếp theo thứ tự tăng dần.
Code mẫu:
` int pivot = arr[high]; // `3
include
` int pivot = arr[high]; // `4
` int pivot = arr[high]; // `5
`{`7
{
`{`9
` int pivot = arr[high]; // `0
` int pivot = arr[high]; // `1
`{`6
` int right = high - 1; //`1
int partition [int arr[], int low, int high]
{
` int right = high - 1; //`4
` int right = high - 1; //`5
` int right = high - 1; //`6
while[true]{
` int right = high - 1; //`8
` int right = high - 1; //`9
` while[true]{`0
` while[true]{`1
` while[true]{`2
` while[true]{`3
}
` while[true]{`4
` while[true]{`5
}
` while[true]{`6
void quickSort[int arr[], int low, int high]
{
`{`0
`{`1
` while[left = right] break; //`4
` if [left >= right] break; //`5
`{`6
` if [left >= right] break; //`7
{
` if [left >= right] break; //`9
` left++; //`0
` left++; //`1
` left++; //`2
` left++; //`3
` left++; //`4
` left++; //`5
`{`6
FAQS [ Câu Hỏi Thường Gặp]
QuickSort có tính ổn định không?
QuickSort thường không có tính ổn định. Điều này có nghĩa là trong quá trình sắp xếp, vị trí tương đối của các phần tử bằng nhau có thể thay đổi. Tuy nhiên, đôi khi có thể điều chỉnh QuickSort để làm cho nó ổn định, nhưng phương pháp này thường yêu cầu thêm chi phí tính toán và không phải là phiên bản tiêu chuẩn của thuật toán.
QuickSort có tính In-place không?
Có, QuickSort được coi là thuật toán in-place. Điều này có nghĩa là nó thực hiện sắp xếp trực tiếp trên mảng ban đầu mà không cần bất kỳ không gian bộ nhớ phụ trợ nào lớn hơn mảng ban đầu. QuickSort chỉ sử dụng một lượng hữu hạn bộ nhớ bổ sung để lưu trữ các chỉ số của mảng và không yêu cầu không gian lưu trữ bổ sung đáng kể cho việc thực hiện sắp xếp.
QuickSort 3 chiều là gì?
QuickSort 3 chiều là một biến thể của thuật toán QuickSort cổ điển. Khi sử dụng QuickSort 3 chiều, mảng được chia thành ba phần thay vì hai phần như trong QuickSort thông thường. Cụ thể, các phần tử trong mảng được phân chia thành ba phần sau quá trình sắp xếp:
- Các phần tử nhỏ hơn hoặc bằng pivot.
- Các phần tử bằng pivot.
- Các phần tử lớn hơn pivot.
Quá trình này giúp giảm số lần di chuyển các phần tử và tăng hiệu suất sắp xếp trong trường hợp mảng chứa nhiều phần tử trùng lặp. Điều này giúp giảm đáng kể thời gian thực hiện trong trường hợp mảng có nhiều phần tử trùng lặp, giúp tối ưu hiệu suất của thuật toán QuickSort.
Lời kết
Dưới đây là một số thông tin về thuật toán khái niệm Quick Sort là gì cũng như hoạt động trong việc sắp xếp mảng. Mong rằng những kiến thức trên sẽ cung cấp cho bạn những hiểu biết cần thiết để phục vụ cho quá trình học tập và làm việc, đặc biệt là đối với những ai đam mê lĩnh vực lập trình.