యాదృచ్ఛిక శోధన (Random Search) అల్గోరిథం Java: పరిచయం, ఇది ఎలా పని చేస్తుంది, ఉదాహరణ

రాండమ్ సెర్చ్ అల్గోరిథం, మోంటే కార్లో సెర్చ్ అని కూడా పిలుస్తారు, ఇది యాదృచ్ఛికత ఆధారంగా శోధించే పద్ధతి. డేటా శ్రేణిలోని ప్రతి మూలకాన్ని వరుసగా తనిఖీ చేయడానికి బదులుగా, ఈ అల్గోరిథం యాదృచ్ఛికంగా పరిశీలించడానికి అనేక మూలకాలను ఎంపిక చేస్తుంది. సీక్వెన్షియల్ సెర్చ్‌తో పోలిస్తే ఈ విధానం సమయం మరియు వనరులను ఆదా చేస్తుంది.

అది ఎలా పని చేస్తుంది

1. దశ 1: మీరు శోధించాలనుకుంటున్న డేటా శ్రేణితో ప్రారంభించండి.

2. దశ 2: పరిశీలించడానికి నిర్దిష్ట సంఖ్యలో మూలకాలను యాదృచ్ఛికంగా ఎంచుకోండి.

3. దశ 3: ఎంచుకున్న ఎలిమెంట్‌లు సెర్చ్ కండిషన్‌తో సరిపోలుతున్నాయో లేదో తనిఖీ చేయండి.

4. దశ 4: సరిపోలే మూలకం కనుగొనబడితే, ఫలితాన్ని అందించండి; లేకపోతే, దశ 2కి తిరిగి వెళ్లండి.

5. దశ 5: మ్యాచ్ కనుగొనబడే వరకు లేదా గరిష్ట ప్రయత్నాల సంఖ్యను చేరుకునే వరకు ప్రక్రియను కొనసాగించండి.

ప్రయోజనాలు మరియు అప్రయోజనాలు

ప్రయోజనాలు:

• వనరు-సమర్థవంతమైనది: సమయం మరియు మెమరీని ఆదా చేస్తుంది, ముఖ్యంగా పెద్ద డేటా శ్రేణుల కోసం.
• యాదృచ్ఛికత: సులభంగా ఊహించదగినది కాదు, యాదృచ్ఛికత అవసరమయ్యే పరిస్థితులకు అనుకూలం.

ప్రతికూలతలు:

• విజయానికి హామీ లేదు: అల్గోరిథం ఆశించిన ఫలితాన్ని కనుగొంటుందనే హామీ లేదు.
• చాలా సమయం పట్టవచ్చు: చెత్త సందర్భంలో, అల్గోరిథం సీక్వెన్షియల్ సెర్చ్ కంటే ఎక్కువ సమయం పట్టవచ్చు.

ఉదాహరణ మరియు వివరణ

శ్రేణిలో పూర్ణాంకాన్ని కనుగొనడానికి యాదృచ్ఛిక శోధన అల్గారిథమ్‌ను ఉపయోగించడం యొక్క క్రింది ఉదాహరణను పరిగణించండి:

import java.util.Random;  
  
public class RandomSearchExample {  
    static int randomSearch(int[] arr, int target) {  
        Random rand = new Random();  
        int maxAttempts = arr.length; // Maximum number of attempts  
        for(int i = 0; i < maxAttempts; i++) {  
            int randomIndex = rand.nextInt(arr.length); // Randomly select an index  
            if(arr[randomIndex] == target) {  
                return randomIndex; // Return the index if found  
            }  
        }  
        return -1; // Return -1 if not found  
    }  
  
    public static void main(String[] args) {  
        int[] numbers = {1, 5, 9, 3, 7};  
        int target = 3;  
        int result = randomSearch(numbers, target);  
        if(result != -1) {  
            System.out.println("Number " + target + " found at index " + result);  
        } else {  
            System.out.println("Number " + target + " not found in the array.");  
        }  
    }  
}  

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