பேராசை அல்காரிதம் (Greedy Algorithm): Java எடுத்துக்காட்டுகளுடன் விளக்கப்பட்டது

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

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

1. படி 1: ஆரம்ப நிலையில் இருந்து தொடங்கவும்.

2. படி 2: ஒவ்வொரு அடியிலும், மதிப்பீட்டுச் செயல்பாட்டின் அடிப்படையில் கிடைக்கக்கூடிய விருப்பங்களில் சிறந்த விருப்பத்தை அல்காரிதம் தேர்ந்தெடுக்கிறது.

3. படி 3: சிறந்த விருப்பத்தைத் தேர்ந்தெடுப்பதன் மூலம் அல்காரிதம் ஒரு புதிய நிலைக்கு நகரும்.

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

5. படி 5: கண்டுபிடிக்கப்பட்ட தீர்வைத் திருப்பித் தரவும்.

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

நன்மைகள்:

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

தீமைகள்:

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

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

பேராசை அல்காரிதத்தின் பொதுவான உதாரணம் "Kth மிகப்பெரிய உறுப்பு" சிக்கலைக் கண்டறிவது. இந்த அல்காரிதம் எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்:

import java.util.Arrays;  
  
public class GreedyAlgorithmExample {  
    static int findKthLargest(int[] nums, int k) {  
        Arrays.sort(nums); // Sort the array  
        return nums[nums.length- k]; // Return the kth largest element  
    }  
  
    public static void main(String[] args) {  
        int[] nums = {3, 1, 2, 4, 5};  
        int k = 2;  
        int result = findKthLargest(nums, k);  
        System.out.println("The " + k + "th largest element is: " + result);  
    }  
}  

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