(String Search) ਵਿੱਚ ਸਤਰ ਖੋਜ ਐਲਗੋਰਿਦਮ Java

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

ਸਤਰ ਖੋਜ ਐਲਗੋਰਿਦਮ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ

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

ਸਟ੍ਰਿੰਗ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੇ ਫਾਇਦੇ ਅਤੇ ਨੁਕਸਾਨ

ਲਾਭ:

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

ਨੁਕਸਾਨ:

• ਵੱਡੇ ਟੈਕਸਟ ਲਈ ਅਕੁਸ਼ਲ: ਸਭ ਤੋਂ ਮਾੜੇ ਹਾਲਾਤਾਂ ਵਿੱਚ, ਐਲਗੋਰਿਦਮ ਦੀ ਸਮਾਂ ਗੁੰਝਲਤਾ ਉੱਚੀ ਹੋ ਸਕਦੀ ਹੈ, ਇਸ ਨੂੰ ਵੱਡੇ ਟੈਕਸਟ ਲਈ ਅਕੁਸ਼ਲ ਬਣਾਉਂਦੀ ਹੈ।
• ਸੀਮਤ ਪੈਟਰਨ ਮੈਚਿੰਗ: ਐਲਗੋਰਿਦਮ ਦਾ ਮੂਲ ਸੰਸਕਰਣ ਗੁੰਝਲਦਾਰ ਪੈਟਰਨ ਮੈਚਿੰਗ ਲੋੜਾਂ ਨੂੰ ਸੰਭਾਲ ਨਹੀਂ ਸਕਦਾ ਹੈ।

ਉਦਾਹਰਨ ਅਤੇ ਵਿਆਖਿਆ

ਆਉ ਵਿੱਚ ਇੱਕ ਵਾਕ ਵਿੱਚ ਇੱਕ ਖਾਸ ਸ਼ਬਦ ਲੱਭਣ ਲਈ ਸਟਰਿੰਗ ਖੋਜ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਤੇ ਵਿਚਾਰ ਕਰੀਏ Java ।

public class StringSearchExample {  
    public static int searchString(String mainString, String substring) {  
        int mainLength = mainString.length();  
        int subLength = substring.length();  
  
        for(int i = 0; i <= mainLength- subLength; i++) {  
            int j;  
  
            for(j = 0; j < subLength; j++) {  
                if(mainString.charAt(i + j) != substring.charAt(j)) {  
                    break;  
                }  
            }  
  
            if(j == subLength) {  
                return i; // Substring found at position i  
            }  
        }  
  
        return -1; // Substring not found  
    }  
  
    public static void main(String[] args) {  
        String text = "The quick brown fox jumps over the lazy dog";  
        String search = "fox";  
  
        int position = searchString(text, search);  
  
        if(position != -1) {  
            System.out.println("Substring found at position: " + position);  
        } else {  
            System.out.println("Substring not found");  
        }  
    }  
}  

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

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