ਬੇਤਰਤੀਬ ਖੋਜ (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.");  
        }  
    }  
}  

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