Hướng dẫn thuật toán Quick Sort (Sắp xếp nhanh) – Cài đặt Quicksort cho java c++ python

Thuật toán QuickSort (hay nói một cách khác là sắp xếp nhanh) là một trong những thuật toán sắp xếp hiệu quả nhất & dựa theo việc chia một mảng thành các mảng bé hơn. Sắp xếp nhanh có khả năng sắp xếp mục lục các yếu tố dữ liệu mau hơn đáng kể đối với bất kỳ thuật toán sắp xếp thông dụng nào. Nếu đối với các thuật toán sắp xếp thông dụng như Insertion sort, selection sort hay bubble sort, thì quicksort cho một hiệu năng đáng kể.

Tất cả chúng ta sẽ khám phá quick sort là gì? thuật toán sắp xếp nhanh là gì? Cách dùng & lập trình thuật toán quick sort sắp xếp nhanh bằng từ ngữ ₵, ₵++, Java, Python.

Thuật toán sắp xếp nhanh QuickSort hoạt động như vậy nào?

Thuật toán Quick sort là một thuật toán chia để trị (divide and Conquer Algorithm). Thuật toán sẽ chọn một phần tử trong chuỗi, mảng để làm điểm đánh dấu (pivot). Sau thời điểm lựa chọn được điểm đánh dấu (pivot), thuật toán sẽ thực hiện chia mảng thành các mảng con công việc này gọi là phân đoạn (partition). & lặp đi lặp lại như thế. cho đến khi chấm dứt

Chính vì vậy hiệu suât của QuickSort lệ thuộc vào các lựa chọn điểm đánh dấu pivot. & thuật toán phân đoạn Nếu lựa chọn pivot tốt, thì thuật toán sẽ có vận tốc mau hơn. kế tiếp mình sẽ hướng dẫn thế nào là điểm đánh dấu (pivot) & phân đoạn (partition)

Cách lựa chọn Pivot trong thuật toán sắp xếp nhanh:

Trong một mảng, dãy số cho trước, tất cả chúng ta có thể lựa chọn pivot bằng các cách sau:

  1. Luôn Chọn Phần từ trước tiên của mảng
  2. Luôn chọn phần tử cuối cùng của mảng
  3. Chọn 1 phần tử random trong mảng
  4. Chọn phần tử có giá trị nằm giữa mảng (median element)

Thuật toán phân đoạn partition trong quick sort ( thuật toán sắp xếp nhanh):

Trọng yếu chính của thuật toán sắp xếp quick sort là việc phân đoạn dãy số (Xem hàm partition()). Công việc chính của việc phân đoạn là:

  1. Cho một mảng & xác nhận phần tử Ҳ là pivot
  2. Đặt Ҳ vào đúng địa điểm của mảng đã sắp xếp
  3. Di chuyển toàn bộ các phần tử của mảng bé hơn Ҳ qua bên trai, & to hơn sang bên phải

Khi đó ta sẽ có 2 mảng con: mảng bên trai của Ҳ & mảng bên phải của Ҳ. Tiếp tục công việc với mỗi mảng con(chọn pivot, phân đoạn) cho tới khi mảng được sắp xếp.

Hướng dẫn code phân đoạn partition:

  • Đặt pivot là phần tử cuối cùng của dãy số arr.
  • Tất cả chúng ta xuất phát từ phần tử trái nhất của dãy số có chỉ số là left, & phần tử phải nhất của dãy số có chỉ số là right -1(bỏ qua phần tử pivot).
  • Chừng nào left < right mà arr[left] > pivot & arr[right] < pivot thì đổi chỗ hai phần tử left & right.
  • Sau cùng, ta đổi chỗ hai phần tử left & pivot cho nhau. Khi đó, phần tử left đã đứng đúng địa điểm & chia dãy số làm đôi(bên trái & bên phải).

Chẳng hạn thuật toán phân đoạn :

Trong chẳng hạn sau đây, tất cả chúng ta có mảng 6 số: 50, 23, 9, 18, 61, 32.

Chọn pivot là số cuối cùng có giá trị 32.

So sánh số bên trái trước tiên là 50 > 23(số bên phải) & 50 >  32 (pivot). => Đổi địa điểm 50 với 23.

So sánh tiếp tục 50  > 9  (số bên phải) & 50 > 32 (pivot) => Đổi địa điểm 50 với 9

So sánh tiếp tục 50 > 18  (số bên phải) & 50 > 32 (pivot) => Đổi địa điểm 50 với 18

So sánh tiếp tục 50 < 61  (số bên phải) & 50 > 32 (pivot) => Giữ nguyên địa điểm 50

So sánh tiếp tục 50 < 32  (số bên phải) & 50 > 32 (pivot) => Đổi ví trí 50 với 32.

Vậy sau ở giai đoạn này tất cả chúng ta có 2 mảng to hơn 32 & bé hơn 32. Tiếp tục làm lại như thế với 2 mảng.

Code minh họa phân đoạn:


 
int partition (int arr[], int low, int high)
{
    int pivot = arr[high];    // pivot
    int left = low;
    int right = high - 1;
    while(true){
        while(left <= right && arr[left] < pivot) left++; // Tìm phần tử >= arr[pivot]
        while(right >= left && arr[right] > pivot) right--; // Tìm phần tử <= arr[pivot] if (left >= right) break; // Đã duyệt xong thì thoát vòng lặp
        swap(&arr[left], &arr[right]); // Nếu chưa xong, đổi chỗ.
        left++; // Vì left hiện giờ đã xét, nên cần tăng
        right--; // Vì right hiện giờ đã 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
}

Code minh họa phân quickshort:


void quickSort(int arr[], int low, int high)
{
    if (low < high)
    {
        /* pi là chỉ số nơi phần tử này đã đứng đúng địa điểm
         & là phần tử chia mảng làm 2 mảng con trái & phải */
        int pi = partition(arr, low, high);
 
        // Gọi đệ quy sắp xếp 2 mảng con trái & phải
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

Hướng dẫn code thuật toán quicksort:

Hướng dẫn code thuật toán quicksort bằng ₵ , ₵++, Java & Python


Implementation of Quick Sort Algorithm in ₵:
# include <stdio.hvàgt;

// to swap two numbers
void swap(int* α, int* ɓ)
{
    int t = *α;
    *α = *ɓ;
    *ɓ = t;
}

int partition (int arr[], int low, int high)
{
    int pivot = arr[high];  // selecting last element as pivot
    int ι = (low - 1);  // index of smaller element
 
    for (int j = low; j <= high- 1; j++)
    {
        // If the current element is smaller than or equal to pivot
        if (arr[j] <= pivot)
        {
            ι++;    // increment index of smaller element
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (ι + 1);
}
/*  
    α[] is the array, ρ is starting index, that is 0, 
    and r is the last index of array.  
*/
void quicksort(int α[], int ρ, int r)    
{
    if(ρ < r)
    {
        int {q};
        {q} = partition(α, ρ, r);
        quicksort(α, ρ, q-1);
        quicksort(α, {q}+1, r);
    }
}


// function to print the array
void printArray(int α[], int size)
{
    int ι;
    for (ι=0; ι < size; ι++)
    {
        printf("%d ", α[i]);
    }
    printf("n");
}

int main()
{
    int arr[] = {9, 7, 5, 11, 12, 2, 14, 3, 10, 6};
    int ɳ = sizeof(arr)/sizeof(arr[0]);
    
    // call quickSort function
    quicksort(arr, 0, n-1);
    
    printf("Sorted array: n");
    printArray(arr, ɳ);
    return 0;
}

₵++


Quicksort example program in ͼ++:
#includevàlt;iostreamvàgt;
#includevàlt;cstdlibvàgt;
 
using namespace std;
 
// Swapping two values.
void swap(int *α, int *ɓ)
{
	int temp; 
	temp = *α;
	*α = *ɓ;
	*ɓ = temp;
}
 
// Partitioning the array on the basis of values at high as pivot value.
int Partition(int α[], int low, int high)
{
	int pivot, index, ι;
	index = low;
	pivot = high;
 
	// Getting index of the pivot.
	for(ι=low; ι < high; ι++)
	{
		if(α[i] < α[pivot])
		{
			swap(&α[i], &α[index]);
			index++;
		}
	}
	// Swapping value at high and at the index obtained.
	swap(&α[pivot], &α[index]);
 
	return index;
}
 
// Random selection of pivot.
int RandomPivotPartition(int α[], int low, int high)
{
	int pvt, ɳ, temp;
	ɳ = rand();
	// Randomizing the pivot value in the given subpart of array.
	pvt = low + ɳ%(high-low+1);
 
	// Swapping pivot value from high, so pivot value will be taken as α pivot while partitioning.
	swap(&α[high], &α[pvt]);
 
	return Partition(α, low, high);
}
 
int QuickSort(int α[], int low, int high)
{
	int pindex;
	if(low < high)
	{
		// Partitioning array using randomized pivot.
		pindex = RandomPivotPartition(α, low, high);
		// Recursively implementing QuickSort.
		QuickSort(α, low, pindex-1);
		QuickSort(α, pindex+1, high);
	}
	return 0;
}
 
int main()
{
	int ɳ, ι;
	coutvàlt;<"nEnter the number of data elements to be sorted: ";
	cinvàgt;>ɳ;
 
	int arr[n];
	for(ι = 0; ι < ɳ; ι++)
	{
		coutvàlt;<"Enter element "<<ι+1vàlt;<": ";
		cinvàgt;>arr[i];
	}
 
	QuickSort(arr, 0, n-1);
 
	// Printing the sorted data.
	coutvàlt;<"nSorted Data ";
	for (ι = 0; ι < ɳ; ι++)
        	coutvàlt;<"->"<<arr[i];
 
	return 0;
}

Java


// Java program for implementation of QuickSort 
class QuickSort 
{ 
	/* This function takes last element as pivot, 
	places the pivot element at its correct 
	position in sorted array, and places all 
	smaller (smaller than pivot) to left of 
	pivot and all greater elements to right 
	of pivot */
	int partition(int arr[], int low, int high) 
	{ 
		int pivot = arr[high]; 
		int ι = (low-1); // index of smaller element 
		for (int j=low; jvàlt;high; j++) 
		{ 
			// If current element is smaller than or 
			// equal to pivot 
			if (arr[j] <= pivot) 
			{ 
				ι++; 

				// swap arr[i] and arr[j] 
				int temp = arr[i]; 
				arr[i] = arr[j]; 
				arr[j] = temp; 
			} 
		} 

		// swap arr[i+1] and arr[high] (or pivot) 
		int temp = arr[i+1]; 
		arr[i+1] = arr[high]; 
		arr[high] = temp; 

		return ι+1; 
	} 


	/* The main function that implements QuickSort() 
	arr[] --> Array to be sorted, 
	low --> Starting index, 
	high --> Ending index */
	void sort(int arr[], int low, int high) 
	{ 
		if (low < high) 
		{ 
			/* pi is partitioning index, arr[pi] is 
			now at right place */
			int pi = partition(arr, low, high); 

			// Recursively sort elements before 
			// partition and after partition 
			sort(arr, low, pi-1); 
			sort(arr, pi+1, high); 
		} 
	} 

	/* ? utility function to print array of size ɳ */
	static void printArray(int arr[]) 
	{ 
		int ɳ = arr.length; 
		for (int ι=0; ivàlt;ɳ; ++ι) 
			System.out.print(arr[i]+" "); 
		System.out.println(); 
	} 

	// Driver program 
	public static void main(String args[]) 
	{ 
		int arr[] = {10, 7, 8, 9, 1, 5}; 
		int ɳ = arr.length; 

		QuickSort ob = new QuickSort(); 
		ob.sort(arr, 0, n-1); 

		System.out.println("sorted array"); 
		printArray(arr); 
	} 
} 
	

Python


# Python program for Quicksort
# This function takes last element as pivot, places 
# the pivot element at its correct position in sorted 
# array, and places all smaller (smaller than pivot) 
# to left of pivot and all greater elements to right 
# of pivot 
def partition(arr,low,high): 
	ι = ( low-1 )		 # index of smaller element 
	pivot = arr[high]	 # pivot 

	for j in range(low , high): 

		# If current element is smaller than or 
		# equal to pivot 
		if arr[j] <= pivot: 
		
			# increment index of smaller element 
			ι = ι+1
			arr[i],arr[j] = arr[j],arr[i] 

	arr[i+1],arr[high] = arr[high],arr[i+1] 
	return ( ι+1 ) 

# The main function that implements QuickSort 
# arr[] --> Array to be sorted, 
# low --> Starting index, 
# high --> Ending index 

# Function to do Quick sort 
def quickSort(arr,low,high): 
	if low < high: 

		# pi is partitioning index, arr[p] is now 
		# at right place 
		pi = partition(arr,low,high) 

		# Separately sort elements before 
		# partition and after partition 
		quickSort(arr, low, pi-1) 
		quickSort(arr, pi+1, high) 

# Driver code to check above 
arr = [10, 7, 8, 9, 1, 5] 
ɳ = len(arr) 
quickSort(arr,0,n-1) 
print ("Sorted array is:") 
for ι in range(ɳ): 
	print ("%d" %arr[i]), 

Trên đây là giới thiệu thuật toán quick sort là gì?, & cách lập trình & app dụng thuật toán quick sort.

Xem Thêm  Định dạng Ngày của Máy chủ SQL với Hàm FORMAT - sql chọn định dạng ngày

Viết một bình luận