(Binary Search) C++ ਵਿੱਚ ਬਾਈਨਰੀ ਖੋਜ ਐਲਗੋਰਿਦਮ- ਵਿਆਖਿਆ, ਉਦਾਹਰਨ, ਅਤੇ ਕੋਡ

ਬਾਈਨਰੀ ਖੋਜ ਐਲਗੋਰਿਦਮ ਇੱਕ ਕ੍ਰਮਬੱਧ ਸੂਚੀ ਵਿੱਚ ਇੱਕ ਖਾਸ ਤੱਤ ਦੀ ਖੋਜ ਕਰਨ ਦਾ ਇੱਕ ਵਧੇਰੇ ਕੁਸ਼ਲ ਤਰੀਕਾ ਹੈ। ਲੀਨੀਅਰ ਖੋਜ ਦੇ ਉਲਟ, ਜੋ ਕ੍ਰਮਵਾਰ ਤੱਤਾਂ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ, ਬਾਈਨਰੀ ਖੋਜ ਸੂਚੀ ਨੂੰ ਅੱਧਿਆਂ ਵਿੱਚ ਵੰਡਦੀ ਹੈ ਅਤੇ ਮਿਡਲ ਐਲੀਮੈਂਟ ਨਾਲ ਟਾਰਗੇਟ ਐਲੀਮੈਂਟ ਦੀ ਤੁਲਨਾ ਕਰਦੀ ਹੈ। ਇਹ ਪ੍ਰਕਿਰਿਆ ਉਦੋਂ ਤੱਕ ਦੁਹਰਾਈ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਤੱਕ ਟੀਚਾ ਤੱਤ ਨਹੀਂ ਮਿਲਦਾ ਜਾਂ ਖੋਜ ਰੇਂਜ ਖਾਲੀ ਨਹੀਂ ਹੋ ਜਾਂਦੀ।

ਕਿਦਾ ਚਲਦਾ

1. ਪੂਰੀ ਕ੍ਰਮਬੱਧ ਸੂਚੀ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ।
2. ਮੌਜੂਦਾ ਖੋਜ ਰੇਂਜ ਦਾ ਮੱਧ ਤੱਤ ਲੱਭੋ।
3. ਮਿਡਲ ਐਲੀਮੈਂਟ ਦੀ ਟੀਚਾ ਮੁੱਲ ਨਾਲ ਤੁਲਨਾ ਕਰੋ।
4. ਜੇ ਮੱਧ ਤੱਤ ਟੀਚੇ ਦੇ ਮੁੱਲ ਦੇ ਬਰਾਬਰ ਹੈ, ਤਾਂ ਖੋਜ ਸਫਲ ਹੈ.
5. ਜੇਕਰ ਵਿਚਕਾਰਲਾ ਤੱਤ ਟੀਚੇ ਤੋਂ ਵੱਡਾ ਹੈ, ਤਾਂ ਰੇਂਜ ਦੇ ਖੱਬੇ ਅੱਧ ਵਿੱਚ ਖੋਜ ਕਰੋ।
6. ਜੇਕਰ ਮੱਧ ਤੱਤ ਟੀਚੇ ਤੋਂ ਛੋਟਾ ਹੈ, ਤਾਂ ਸੀਮਾ ਦੇ ਸੱਜੇ ਅੱਧ ਵਿੱਚ ਖੋਜ ਕਰੋ।
7. ਕਦਮ 2-6 ਨੂੰ ਉਦੋਂ ਤੱਕ ਦੁਹਰਾਓ ਜਦੋਂ ਤੱਕ ਟੀਚਾ ਤੱਤ ਨਹੀਂ ਮਿਲਦਾ ਜਾਂ ਖੋਜ ਰੇਂਜ ਖਾਲੀ ਨਹੀਂ ਹੋ ਜਾਂਦੀ।

ਉਦਾਹਰਨ

ਆਓ ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਕ੍ਰਮਬੱਧ ਸੂਚੀ 'ਤੇ ਵਿਚਾਰ ਕਰੀਏ ਅਤੇ ਬਾਈਨਰੀ ਖੋਜ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨੰਬਰ 34 ਨੂੰ ਲੱਭਣਾ ਚਾਹੁੰਦੇ ਹਾਂ।

ਕ੍ਰਮਬੱਧ ਸੂਚੀ: {12, 23, 34, 45, 56, 67, 89, 90}

1. ਪੂਰੀ ਸੂਚੀ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ.
2. ਮੱਧ ਤੱਤ: 56(ਸਥਿਤੀ 4). 34 ਨਾਲ ਤੁਲਨਾ ਕਰੋ।
3. 56 34 ਤੋਂ ਵੱਡਾ ਹੈ। ਖੱਬੇ ਅੱਧ ਵਿੱਚ ਖੋਜੋ।
4. ਨਵਾਂ ਮੱਧ ਤੱਤ: 23(ਸਥਿਤੀ 1) 34 ਨਾਲ ਤੁਲਨਾ ਕਰੋ।
5. 23 34 ਤੋਂ ਛੋਟਾ ਹੈ। ਸੱਜੇ ਅੱਧ ਵਿੱਚ ਖੋਜੋ।
6. ਨਵਾਂ ਮੱਧ ਤੱਤ: 45(ਸਥਿਤੀ 3) 34 ਨਾਲ ਤੁਲਨਾ ਕਰੋ।
7. 45 34 ਤੋਂ ਵੱਡਾ ਹੈ। ਖੱਬੇ ਅੱਧ ਵਿੱਚ ਖੋਜੋ।
8. ਨਵਾਂ ਮੱਧ ਤੱਤ: 34(ਸਥਿਤੀ 2) ਟੀਚਾ ਮਿਲਿਆ।

C++ ਵਿੱਚ ਉਦਾਹਰਨ ਕੋਡ

#include <iostream>  
#include <vector>  
  
int binarySearch(const std::vector<int>& arr, int target) {  
    int left = 0;  
    int right = arr.size()- 1;  
  
    while(left <= right) {  
        int mid = left +(right- left) / 2;  
  
        if(arr[mid] == target) {  
            return mid;  
        } else if(arr[mid] < target) {  
            left = mid + 1;  
        } else {  
            right = mid- 1;  
        }  
    }  
  
    return -1;  
}  
  
int main() {  
    std::vector<int> numbers = {12, 23, 34, 45, 56, 67, 89, 90};  
    int target = 34;  
  
    int result = binarySearch(numbers, target);  
  
    if(result != -1) {  
        std::cout << "Element " << target << " found at position " << result << std::endl;  
    } else {  
        std::cout << "Element " << target << " not found in the array" << std::endl;  
    }  
  
    return 0;  
}  

ਦਿੱਤੀ ਗਈ ਉਦਾਹਰਨ ਵਿੱਚ, binarySearch ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਲੜੀਬੱਧ ਸੂਚੀ ਵਿੱਚ ਨੰਬਰ 34 ਨੂੰ ਲੱਭਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਨਤੀਜਾ ਸੂਚੀ ਵਿੱਚ 34 ਦੀ ਸਥਿਤੀ ਹੋਵੇਗੀ(ਪੋਜ਼ੀਸ਼ਨ 0 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ) ਜਾਂ -1 ਜੇਕਰ ਨੰਬਰ ਨਹੀਂ ਮਿਲਦਾ ਹੈ।