சரம் தேடல் (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.