வணக்கம்! இன்றைய பாடம் மற்றவற்றிலிருந்து சற்று வித்தியாசமாக இருக்கும். இது ஜாவாவுடன் மட்டுமே மறைமுகமாக தொடர்புடையதாக இருக்கும். ஒவ்வொரு புரோகிராமருக்கும் இந்த தலைப்பு மிகவும் முக்கியமானது என்று கூறினார். நாங்கள் அல்காரிதம்களைப் பற்றி பேசப் போகிறோம் . அல்காரிதம் என்றால் என்ன? எளிமையான சொற்களில், இது விரும்பிய முடிவை அடைய முடிக்க வேண்டிய சில செயல்களின் வரிசையாகும் . அன்றாட வாழ்வில் நாம் அடிக்கடி அல்காரிதம்களைப் பயன்படுத்துகிறோம். உதாரணமாக, தினமும் காலையில் உங்களுக்கு ஒரு குறிப்பிட்ட பணி உள்ளது: பள்ளி அல்லது வேலைக்குச் செல்லுங்கள், அதே நேரத்தில்:
- ஆடைகள்
- சுத்தமான
- ஊட்டி
- அலாரம் கடிகாரத்தைப் பயன்படுத்தி எழுந்திருங்கள்.
- குளித்துவிட்டு துவையுங்கள்.
- காலை உணவு மற்றும் காபி அல்லது தேநீர் தயாரிக்கவும்.
- சாப்பிடு.
- முந்தைய மாலை உங்கள் துணிகளை நீங்கள் அயர்ன் செய்யவில்லை என்றால், அவற்றை அயர்ன் செய்யுங்கள்.
- உடுத்திக்கொள்ளுங்கள்.
- வீட்டை விட்டு வெளியேறு.
- வெப்ஸ்டரின் மூன்றாவது புதிய சர்வதேச அகராதியின் 1961 பதிப்பை வாங்கவும் அல்லது பதிவிறக்கவும்.
- இந்த அகராதியில் எங்கள் பட்டியலில் இருந்து ஒவ்வொரு பெயரையும் கண்டறியவும்.
- ஒரு காகிதத்தில், பெயர் அமைந்துள்ள அகராதியின் பக்கத்தை எழுதுங்கள்.
- பெயர்களை வரிசைப்படுத்த காகித துண்டுகளைப் பயன்படுத்தவும்.
for
இந்த பணியைச் செய்யும் ஒரு சாதாரண வளையத்தை நீங்கள் எழுதுகிறீர்கள்
int[] numbers = new int[100];
// ...fill the array with numbers
for (int i: numbers) {
System.out.println(i);
}
இந்த அல்காரிதத்தின் சிக்கலானது என்ன? நேரியல், அதாவது O(n). நிரல் செய்ய வேண்டிய செயல்களின் எண்ணிக்கை அதற்கு எத்தனை எண்கள் அனுப்பப்படுகின்றன என்பதைப் பொறுத்தது. வரிசையில் 100 எண்கள் இருந்தால், 100 செயல்கள் இருக்கும் (திரையில் சரங்களைக் காண்பிப்பதற்கான அறிக்கைகள்). வரிசையில் 10,000 எண்கள் இருந்தால், 10,000 செயல்களைச் செய்ய வேண்டும். நமது அல்காரிதத்தை எந்த வகையிலும் மேம்படுத்த முடியுமா? இல்லை. எதுவாக இருந்தாலும், கன்சோலில் ஸ்டிரிங்க்களைக் காட்ட, வரிசையின் வழியாக N பாஸ்களை உருவாக்கி, N அறிக்கைகளை இயக்க வேண்டும் . மற்றொரு உதாரணத்தைக் கவனியுங்கள்.
public static void main(String[] args) {
LinkedList<Integer> numbers = new LinkedList<>();
numbers.add(0, 20202);
numbers.add(0, 123);
numbers.add(0, 8283);
}
எங்களிடம் காலியாக உள்ளது LinkedList
, அதில் பல எண்களைச் செருகுவோம். எங்கள் எடுத்துக்காட்டில் ஒற்றை எண்ணைச் செருகுவதற்கான வழிமுறை சிக்கலை மதிப்பீடு செய்ய வேண்டும் LinkedList
, மேலும் அது பட்டியலில் உள்ள உறுப்புகளின் எண்ணிக்கையைப் பொறுத்தது. பதில் O(1), அதாவது நிலையான சிக்கலானது . ஏன்? பட்டியலின் தொடக்கத்தில் ஒவ்வொரு எண்ணையும் செருகுவோம். கூடுதலாக, நீங்கள் ஒரு எண்ணில் ஒரு எண்ணைச் செருகும்போது LinkedList
, உறுப்புகள் எங்கும் நகராது என்பதை நீங்கள் நினைவுபடுத்துவீர்கள். இணைப்புகள் (அல்லது குறிப்புகள்) புதுப்பிக்கப்பட்டன (LinkedList எப்படி வேலை செய்கிறது என்பதை மறந்துவிட்டால், எங்கள் பழைய பாடங்களில் ஒன்றைப் பார்க்கவும் ). எங்கள் பட்டியலில் முதல் எண் x
, மற்றும் பட்டியலின் முன்புறத்தில் y எண்ணைச் செருகினால், நாம் செய்ய வேண்டியது இதுதான்:
x.previous = y;
y.previous = null;
y.next = x;
இணைப்புகளைப் புதுப்பிக்கும் போது, ஏற்கனவே எத்தனை எண்கள் உள்ளனLinkedList
, அது ஒன்று அல்லது ஒரு பில்லியனாக இருந்தாலும் நாங்கள் கவலைப்பட மாட்டோம். அல்காரிதத்தின் சிக்கலானது நிலையானது, அதாவது O(1).