(Binary Search) માં બાઈનરી શોધ અલ્ગોરિધમ Java

દ્વિસંગી શોધ અલ્ગોરિધમ Java પ્રોગ્રામિંગમાં એક કાર્યક્ષમ પદ્ધતિ છે, જેનો ઉપયોગ સૉર્ટ કરેલ એરેમાં ચોક્કસ મૂલ્ય શોધવા માટે થાય છે. આ અભિગમ એરેને સતત બે ભાગોમાં વિભાજિત કરે છે અને મધ્ય તત્વ સાથે શોધ મૂલ્યની તુલના કરે છે.

બાઈનરી શોધ અલ્ગોરિધમ કેવી રીતે કામ કરે છે

દ્વિસંગી શોધ અલ્ગોરિધમ એરેના મધ્યમ તત્વ સાથે શોધ મૂલ્યની તુલના કરીને શરૂ થાય છે. જો શોધ મૂલ્ય મધ્યમ તત્વની સમાન હોય, તો અલ્ગોરિધમ તે તત્વની સ્થિતિ પરત કરે છે. જો શોધ મૂલ્ય મધ્યમ તત્વ કરતા ઓછું હોય, તો અલ્ગોરિધમ એરેના ડાબા અડધા ભાગમાં શોધ ચાલુ રાખે છે. જો શોધ મૂલ્ય વધારે હોય, તો અલ્ગોરિધમ એરેના જમણા અડધા ભાગમાં શોધ ચાલુ રાખે છે. જ્યાં સુધી શોધ મૂલ્ય ન મળે અથવા શોધવા માટે કોઈ વધુ ઘટકો ન હોય ત્યાં સુધી આ પ્રક્રિયા પુનરાવર્તિત થાય છે.

દ્વિસંગી શોધ અલ્ગોરિધમના ફાયદા અને ગેરફાયદા

ફાયદા:

• ઉચ્ચ કાર્યક્ષમતા: આ અલ્ગોરિધમ મોટા એરેની શોધને ઑપ્ટિમાઇઝ કરીને, દરેક પગલામાં અડધા ઘટકોને દૂર કરે છે.
• ઓછા સમયની જટિલતા: આ અલ્ગોરિધમનો સમય જટિલતા O(log n) છે, જે તેને મોટા ડેટાસેટ્સ માટે અસરકારક બનાવે છે.

ગેરફાયદા:

• સૉર્ટ કરેલ એરે આવશ્યકતા: અલ્ગોરિધમ ફક્ત સૉર્ટ કરેલ એરે સાથે કામ કરે છે.

ઉદાહરણ અને સમજૂતી

માં સૉર્ટ કરેલ પૂર્ણાંક એરેમાં ચોક્કસ પૂર્ણાંક શોધવા માટે દ્વિસંગી શોધ અલ્ગોરિધમનો ઉપયોગ કરવાના ઉદાહરણનો વિચાર કરો Java.

public class BinarySearchExample {  
    public static int binarySearch(int[] array, int target) {  
        int left = 0;  
        int right = array.length- 1;  
  
        while(left <= right) {  
            int mid = left +(right- left) / 2;  
  
            if(array[mid] == target) {  
                return mid; // Return position if found  
            } else if(array[mid] < target) {  
                left = mid + 1;  
            } else {  
                right = mid- 1;  
            }  
        }  
        return -1; // Return -1 if not found  
    }  
  
    public static void main(String[] args) {  
        int[] numbers = { 1, 3, 5, 7, 9, 11, 13, 15 };  
        int target = 9;  
  
        int position = binarySearch(numbers, target);  
  
        if(position != -1) {  
            System.out.println("Element " + target + " found at position " + position);  
        } else {  
            System.out.println("Element " + target + " not found in the array");  
        }  
    }  
}  

આ ઉદાહરણમાં, અમે ક્રમાંકિત પૂર્ણાંક એરેમાં નંબર 9 શોધવા માટે બાઈનરી શોધ અલ્ગોરિધમનો ઉપયોગ કરીએ છીએ. અલ્ગોરિધમ એરે દ્વારા પુનરાવર્તિત થાય છે અને મધ્ય મૂલ્ય સાથે શોધ મૂલ્યની તુલના કરે છે. આ કિસ્સામાં, નંબર 9 એરેમાં પોઝિશન 4(0-આધારિત ઇન્ડેક્સ) પર જોવા મળે છે.

જ્યારે આ ઉદાહરણ દર્શાવે છે કે દ્વિસંગી શોધ અલ્ગોરિધમ કેવી રીતે સૉર્ટ કરેલ પૂર્ણાંક એરેમાં તત્વ શોધી શકે છે, તે Java પ્રોગ્રામિંગમાં અન્ય શોધ દૃશ્યો પર પણ લાગુ કરી શકાય છે.