(Linear Search) இதில் நேரியல் தேடல் அல்காரிதம் Java: உறுப்புகளை ஆராய்ந்து கண்டறிதல்

லீனியர் தேடல் அல்காரிதம் என்பது நிரலாக்கத்தில் ஒரு எளிய மற்றும் அடிப்படை முறையாகும் Java, இது ஒரு பட்டியல் அல்லது வரிசைக்குள் ஒரு குறிப்பிட்ட உறுப்பைக் கண்டறியப் பயன்படுகிறது. இந்த அணுகுமுறை ஒவ்வொரு உறுப்புகளையும் கடந்து தேடல் மதிப்புடன் ஒப்பிடுவதன் மூலம் செயல்படுகிறது.

நேரியல் தேடல் அல்காரிதம் எவ்வாறு செயல்படுகிறது

லீனியர் தேடல் அல்காரிதம் பட்டியல் அல்லது வரிசையின் முதல் உறுப்பிலிருந்து தொடங்குகிறது. இது தேடல் மதிப்பை தற்போதைய உறுப்பின் மதிப்புடன் ஒப்பிடுகிறது. தொடர்புடைய மதிப்பு கண்டறியப்பட்டால், அல்காரிதம் பட்டியல் அல்லது வரிசையில் உள்ள உறுப்பு நிலையை வழங்குகிறது. கண்டுபிடிக்கப்படவில்லை எனில், அல்காரிதம் அடுத்த உறுப்புக்கு நகர்கிறது மற்றும் மதிப்பு கண்டறியப்படும் வரை அல்லது அனைத்து உறுப்புகளும் கடந்து செல்லும் வரை ஒப்பீட்டு செயல்முறையைத் தொடர்கிறது.

நேரியல் தேடல் அல்காரிதத்தின் நன்மைகள் மற்றும் தீமைகள்

நன்மைகள்:

• எளிமையானது மற்றும் புரிந்துகொள்ளக்கூடியது: இந்த அல்காரிதம் செயல்படுத்தவும் புரிந்துகொள்ளவும் எளிதானது.
• எந்த தரவு வகையிலும் வேலை செய்கிறது: எந்த வகையான பட்டியல் அல்லது வரிசை தரவுகளுக்கும் நேரியல் தேடலைப் பயன்படுத்தலாம்.

தீமைகள்:

• குறைந்த செயல்திறன்: இந்த அல்காரிதத்திற்கு பட்டியல் அல்லது வரிசையில் உள்ள அனைத்து உறுப்புகளையும் கடந்து செல்ல வேண்டும், இது பெரிய தரவுத்தொகுப்புகளுக்கு குறைந்த செயல்திறனுக்கு வழிவகுக்கும்.

எடுத்துக்காட்டு மற்றும் விளக்கம்

ஒரு முழு எண் வரிசையில் ஒரு குறிப்பிட்ட முழு எண்ணைக் கண்டறிய நேரியல் தேடல் அல்காரிதத்தைப் பயன்படுத்துவதற்கான உதாரணத்தைக் கவனியுங்கள் Java.

public class LinearSearchExample {  
    public static int linearSearch(int[] array, int target) {  
        for(int i = 0; i < array.length; i++) {  
            if(array[i] == target) {  
                return i; // Return position if found  
            }  
        }  
        return -1; // Return -1 if not found  
    }  
  
    public static void main(String[] args) {  
        int[] numbers = { 4, 2, 7, 1, 9, 5 };  
        int target = 7;  
  
        int position = linearSearch(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");  
        }  
    }  
}  

இந்த எடுத்துக்காட்டில், ஒரு முழு எண் வரிசையில் எண் 7 ஐக் கண்டறிய நேரியல் தேடல் அல்காரிதத்தைப் பயன்படுத்துகிறோம். அல்காரிதம் ஒவ்வொரு உறுப்பு வழியாகவும் சென்று அதை தேடல் மதிப்புடன் ஒப்பிடுகிறது. இந்த வழக்கில், வரிசையில் 2(0-அடிப்படையான குறியீட்டு) இல் எண் 7 காணப்படுகிறது.

Java இந்த உதாரணம், லீனியர் தேடல் அல்காரிதம் ஒரு முழு எண் வரிசையில் ஒரு உறுப்பை எவ்வாறு கண்டறிய முடியும் என்பதை நிரூபிக்கும் அதே வேளையில், நிரலாக்கத்தில் உள்ள மற்ற தேடல் காட்சிகளுக்கும் இது பயன்படுத்தப்படலாம் .