బైనరీ శోధన (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ని కనుగొనడానికి మేము బైనరీ శోధన అల్గారిథమ్‌ని ఉపయోగిస్తాము. అల్గోరిథం శ్రేణి ద్వారా పునరావృతమవుతుంది మరియు శోధన విలువను మధ్య విలువతో సరిపోల్చుతుంది. ఈ సందర్భంలో, శ్రేణిలో స్థానం 4(0-ఆధారిత సూచిక) వద్ద సంఖ్య 9 కనుగొనబడింది.

Java క్రమబద్ధీకరించబడిన పూర్ణాంకాల శ్రేణిలో బైనరీ శోధన అల్గోరిథం ఒక మూలకాన్ని ఎలా కనుగొనగలదో ఈ ఉదాహరణ ప్రదర్శిస్తున్నప్పటికీ, ఇది ప్రోగ్రామింగ్‌లోని ఇతర శోధన దృశ్యాలకు కూడా వర్తించబడుతుంది .