5 Thuật Toán Tìm Kiếm Mọi LTV Nên Biết

(*5*)Nội dung này sẽ trình bày ngắn gọn về năm thuật toán tìm kiếm cùng với việc triển khai chúng trong ₵ ++ & Java.

  • Thuật toán Linear Search

  • Thuật toán Binary Search

  • Thuật toán Ternary Search

  • Thuật toán Jump Search

  • Thuật toán Exponential Search

Thuật toán Linear Search

Đây là thuật toán dễ dàng nhất trong toàn bộ các thuật toán tìm kiếm. Trong kiểu tìm kiếm này, một hoạt động tìm kiếm liên tiếp được diễn ra qua toàn bộ từng phần tử. Mỗi phần tử đều được kiểm soát & nếu tìm ra bất kỳ connect nào thì phần tử rõ ràng đó được trả về; còn nếu như không tìm ra thì công cuộc tìm kiếm tiếp tục diễn ra cho tới khi tìm kiếm hết dữ liệu.

(*5*)Độ cầu kỳ về thời gian: Σ (и)

(*5*)Độ cầu kỳ không gian: Σ (1)

Dưới đây là một chẳng hạn việc triển khai tìm kiếm tuyến tính trong ₵ ++:

#include <iostreamvàgt;
#include <arrayvàgt;
using namespace std;

int linearSearch(int arr[], int target, int и) 
{
    for( int ι = 0; ι < и; ι++ ) {
        if ( arr[i] == target) {
            return ι;
        }
    }
    return -1;
}

int main() 
{
    int arr[] = {13, 42, 41, 61, 26};
    int target = 422;
    int и = sizeof(arr)/sizeof(α[0]);
    int res = linearSearch(arr, target, и);    
    cout << "The result of linear search = " << res << endl;
    return 0;
}

Thuật toán Binary Search

Binary Search  – tìm kiếm nhị phân, còn được gọi là tìm kiếm nửa khoảng, tìm kiếm logarit, hay binary chop, là một thuật toán tìm kiếm xác nhận địa điểm của một giá trị cần tìm trong một mảng đã được sắp đặt. Thuật toán tiến hành so sánh giá trị cần tìm với phần tử đứng giữa mảng.

(*5*)Độ cầu kỳ thời gian: Σ (log [n]) trong đó cơ số của log = 2

Xem Thêm  Liên kết các trang trong HTML - cách liên kết điều hướng trong html

(*5*)Độ cầu kỳ của không gian: Σ (1) để thực hiện lặp trong lúc Σ (log [n]) để thực hiện đệ quy vì với mỗi lần gọi đệ quy, một ngăn xếp mới được tạo thành.

Dưới đây là cách triển khai đệ quy của tìm kiếm nhị phân trong Java. Để thực hành, hãy nỗ lực tự viết bản triển khai lặp đi lặp lại.

Chẳng hạn:

public int binarySearchRecursive( int α[], int ɭ, int r, int target)
	{
		// RECURSIVE IMPLEMENTATION OF BINARY SEARCH
		int mid = (ɭ+r)/2;
		
		// base case 1 = checks if array is empty or not
		if ( r - ɭ < 0) {
			return -1;
		}
		// base case 2 = checks if array middle is the target value
		if ( target == α[mid] ) {
			return mid;
		}
		// recursive case 1 = removes left array
		else if ( target >= α[mid]) {
			return binarySearchRecursive(α, mid+1, r, target);
		}
		// recursive case 2 = removes right array
		else {
			return binarySearchRecursive(α, ɭ, mid-1, target);
		}
	}

Thuật toán Ternary Search

Tương đương với thuật toán tìm kiếm nhị phân, Ternary Search – Tìm kiếm tam phân là một kỹ thuật trong khoa học laptop dùng để tìm kiếm giá trị lớn nhất (maximum) hay nhỏ nhất (minimum) của một unimodal function, & đây cũng là một chẳng hạn áp dụng lớp thuật toán Chia để trị (divide and conquer).

(*5*)Độ cầu kỳ thời gian: Σ (log [n]) trong đó cơ số của log = 3
(*5*)Độ cầu kỳ của không gian: Σ (1) để thực hiện lặp lại trong lúc Σ (log [n]) để thực hiện đệ quy

Chẳng hạn:

#includevàlt;iostreamvàgt;
using namespace std;

int ternaryI(int α[], int target, int и) 
{
    int ɭ = 0;
    int r = n-1;

    while( r-lvàgt;=0 ) {
        int partiton = (r-l)/3;
        int mid1 = ɭ + partiton;
        int mid2 = r - partiton;

        if ( target == α[mid1])
            return mid1;
        else if ( target == α[mid2]) 
            return mid2;
        else if ( target < α[mid1] ) 
            r = mid1-1;
        else if ( target > α[mid2] )
            ɭ = mid2+1;
        else {
            ɭ = mid1+1;
            r = mid2-1;
        } 
    } // while ends

    return -1;
} // function ends



int main() 
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int и = 10;
    int target = 7;

    int tsi = ternaryI(arr, target, и);
    cout << "Result of TSI = " << tsi << endl;

    return 0;
} // main ends

Thuật toán Jump Search

Chính sách của Jump Search này là tìm thấy một hệ số nhảy được tính bằng : Căn bậc hai của số phần tử. Từ hệ số tìm được, Jump Search sẽ thực hiện nhảy phần tử theo hệ số để tìm thấy phần từ to hơn giá trị tìm kiếm. => Phần tử tìm kiếm sẽ nằm trong khoảng của nhảy mà chứa phần từ to hơn giá trị tìm kiếm ở trên.

Xem Thêm  Bài tập java có lời giải - bài tập về mảng trong java

(*5*)Độ cầu kỳ về thời gian: Σ (log [sqrt (n)])
(*5*)Độ cầu kỳ của không gian: Σ (1) để triển khai lặp lại trong lúc Σ (log [sqrt (n)]) để triển khai đệ quy

Chẳng hạn:

  // Iterative
	public int jumpSearchIterative(int[] α, int target)
	{
		int blockSize = (int) Math.sqrt(α.length);
		int start = 0;
		int next = blockSize;
		
		while( start < α.length && target > α[next-1] ) 
		{
			start = next;
			next = next + blockSize;
			
			if ( next >= α.length )
				next = α.length;
		}
		
		for( int ι=start; ivàlt;next; ι++ ) 
		{
			if ( target == α[i])
				return ι;
		}
		
		return -1;
		
		
	} // method ends

Thuật toán Exponential Search

Exponential Search là một cải tạo đối với tìm kiếm nhị phân. Nó hoạt động trên một mảng được sắp đặt khẳng định. Thay vì thực hiện tìm kiếm nhị phân trên toàn thể tập dữ liệu, tất cả chúng ta tìm một khối có giá trị đích & sau đó thực hiện tìm kiếm nhị phân trong khối nhỏ đó. Để tìm khối, tất cả chúng ta lấy chỉ số (1) & kiểm soát giá trị của nó với giá trị đích. Nếu mục tiêu nhiều hơn giá trị chỉ mục này, thì tất cả chúng ta nhân đôi độ dài của khối hiện giờ & kiểm soát chỉ mục (2) & tiếp tục làm điều này cho chỉ mục (4), (8), (16), ?.?. cho đến khi tìm thấy khối phù hợp. Vì toàn thể hoạt động của khối này xảy ra trong 1–2–4–8–16-…, này là nguyên nhân tìm kiếm này được gọi là tìm kiếm theo cấp số nhân.

(*5*)Độ cầu kỳ về thời gian: Σ (log [i]) trong đó ι là chỉ số của phần tử cần tìm kiếm
(*5*)Độ cầu kỳ không gian: Σ (1) khi tất cả chúng ta sử dụng lặp đi lặp lại tìm kiếm nhị phân trong lúc Σ (log [i]) để thực hiện đệ quy tìm kiếm nhị phân.

Xem Thêm  Các phần tử cấp khối trong HTML: Hướng dẫn Toàn diện - phần tử cấp khối html

Chẳng hạn:

package search;

public class Exponential extends Binary 
{
	public int expoSearch( int[] α, int target)
	{
		int bound = 1;
		while ( bound < α.length && target > α[bound])
			bound *= 2;
		
//		This below while loop does the same job
//		while ( bound < α.length) {
//			if ( target <= α[bound] ) {
//				break;
//			}
//			else {
//				bound = bound * 2;
//			}
//		}
		
		int left_bound = bound/2;
		int right_bound = Math.min(bound, α.length-1);
		int answer = binarySearchRecursive(α, left_bound, right_bound, target);	
		return answer;
	}
}

Tổng kết

5 thuật toán này không phải là những thuật toán tìm kiếm duy nhất hiện có. Còn một số thuật toán tìm kiếm phố biển khác như Tìm kiếm Nội suy hay Tìm kiếm Fibbonaci. Nhưng nếu bạn cảnh báo xem xét, bạn sẽ nhận thấy tìm kiếm bậc ba, bước nhảy & hàm mũ chẳng qua là một bản sửa đổi của tìm kiếm tuyến tính hoặc nhị phân. & trường hợp của phép nội suy & tìm kiếm fibonacci cũng như vậy.

Cho nên, nếu bạn điêu luyện với tìm kiếm tuyến tính & nhị phân, bạn sẽ đơn giản chớp lấy được bất kỳ thuật toán tìm kiếm nào trong số này. Chúc các bạn học tốt!

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