சேகரிப்புகளைப் பயன்படுத்துவதற்கான உதவிக்குறிப்புகள்

1. தொகுப்புகளின் பட்டியல்

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

சேகரிப்பு தொடர்பான முக்கிய இடைமுகங்களை நினைவுபடுத்த முயற்சிப்போம்:

பட்டியல் , அமை , வரைபடம் மற்றும் வரிசை .

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

1. பட்டியல்

அதிகம் பயன்படுத்தப்படும் சேகரிப்புடன் ஆரம்பிக்கலாம்.

ஒரு சாதாரண பழைய வரிசைக்கு முடிந்தவரை நெருக்கமாக பட்டியலிடுங்கள் .

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

2. அமை

தொகுப்பு முற்றிலும் மாறுபட்ட அமைப்பைக் கொண்டுள்ளது.

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

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

3. வரைபடம்

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

வரைபடத்திற்கு , இந்த உறவுகள் முக்கிய மதிப்பு ஜோடிகள் என்று அழைக்கப்படுகின்றன.

ஆசிரியர் பொருட்களை விசைகளாகவும், புத்தகங்களின் பட்டியல்களை ( பட்டியல் பொருள்கள்) மதிப்புகளாகவும் பயன்படுத்துவதன் மூலம் இந்த கட்டமைப்பை எங்கள் நூலகத்தில் பயன்படுத்தலாம். எனவே, நூலகத்தில் ஆசிரியர் பொருள் இருக்கிறதா என்று பார்க்க ஒரு தொகுப்பைச் சரிபார்த்த பிறகு , வரைபடத்திலிருந்து அவருடைய புத்தகங்களின் பட்டியலைப் பெற அதே ஆசிரியர் பொருளைப் பயன்படுத்தலாம் .

4. வரிசை

வரிசை என்பது ஒரு தொகுப்பு - ஆச்சரியம்! - ஒரு வரிசையின் நடத்தையை செயல்படுத்துகிறது. வரிசையானது LIFO (கடைசியில், முதலில் வெளியேறியது) அல்லது FIFO (முதலில், முதலில் வெளியேறுதல்) ஆக இருக்கலாம். மேலும் என்னவென்றால், வரிசை இருதரப்பு அல்லது "இரட்டை முனையாக" இருக்கலாம்.

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

புதிதாக வரும் பார்வையாளர்களை வரிசையில் சேர்த்து , அவர்கள் வரும் புத்தகங்களை வழங்குவதன் மூலம் அவர்களுக்கு சேவை செய்யலாம்.

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

2. சிக்கலானது

ஏற்கனவே குறிப்பிட்டுள்ளபடி, நாங்கள் மேலே கருதிய தொகுப்புகள் இடைமுகங்கள் ஆகும், அதாவது அவற்றைப் பயன்படுத்துவதற்கு அவை செயல்படுத்தப்பட வேண்டும்.

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

ஒரு வேலைக்கான சரியான கருவியைத் தேர்ந்தெடுக்கும்போது, ​​பொதுவாக 2 பண்புகளைப் பார்க்கிறோம்:

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

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

கம்ப்யூட்டிங்கில், ஒரு கருவியின் வேகம் பெரும்பாலும் நேர சிக்கலின் அடிப்படையில் வெளிப்படுத்தப்படுகிறது மற்றும் பெரிய எழுத்தான O மூலம் குறிக்கப்படுகிறது.

உலகில் நேரம் சிக்கலானது என்ன?

எளிமையான சொற்களில், நேர சிக்கலானது ஒரு குறிப்பிட்ட செயலைச் செய்ய சேகரிப்பில் உள்ள அல்காரிதம் தேவைப்படும் நேரத்தைக் குறிக்கிறது (உறுப்பைச் சேர்ப்பது/அகற்றுவது, ஒரு உறுப்பைத் தேடுவது).

ArrayList vs LinkedList

பட்டியல் இடைமுகத்தின் இரண்டு செயலாக்கங்களைப் பயன்படுத்தி இதைப் பார்ப்போம் - ArrayList மற்றும் LinkedList .

வெளிப்புறத் தோற்றங்களுக்கு, இந்தத் தொகுப்புகளுடன் பணிபுரிவது ஒத்ததாகும்:

List<String> arrayList = new ArrayList<>();
arrayList.add(String);
arrayList.get(index);
arrayList.remove(index);
arrayList.remove(String);
 
List<String> linkedList = new LinkedList<>();
 
linkedList.add(String);
 
linkedList.get(index);
linkedList.remove(index);
linkedList.remove(String);
    

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

பட்டியல் இடைமுகத்தின் வெவ்வேறு செயலாக்கங்களின் காரணமாக , இந்த இரண்டு கட்டமைப்புகளும் மற்றவர்களை விட மிகவும் திறமையாக வெவ்வேறு செயல்களைச் செய்கின்றன.

ஒரு உறுப்பை அகற்றி சேர்ப்பதைக் கவனியுங்கள்.

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

எங்களிடம் 5 உறுப்புகளின் பட்டியல் உள்ளது மற்றும் 3 வது ஒன்றை அகற்ற வேண்டும் என்று வைத்துக்கொள்வோம்.

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
list.remove(2);
    

இந்த வழக்கில், அகற்றுதல் ஒரு கலத்தை விடுவிக்கிறது, எனவே 3 வது இருந்த 4 வது உறுப்பையும், 4 வது இருந்த 5 வது உறுப்பையும் எழுத வேண்டும்.

இது மிகவும் திறமையற்றது.

பட்டியலின் நடுவில் ஒரு உறுப்பைச் சேர்க்கும்போதும் இதுவே நடக்கும்.

LinkedList வித்தியாசமாக கட்டமைக்கப்பட்டுள்ளது. உறுப்புகளைச் சேர்ப்பது அல்லது அகற்றுவது விரைவானது, ஏனெனில் முந்தைய மற்றும் அடுத்த உறுப்புகளில் உள்ள குறிப்புகளை மட்டுமே மாற்ற வேண்டும், அதன் மூலம் உறுப்புகளின் சங்கிலியிலிருந்து நாம் அகற்றும் பொருளைத் தவிர்த்துவிடுவோம்.

5 உறுப்புகளின் அதே பட்டியலின் உதாரணத்திற்குத் திரும்பினால், 3 வது உறுப்பை அகற்றிய பிறகு, நாம் செய்ய வேண்டியதெல்லாம், 2வது உறுப்பின் குறிப்பை அடுத்த உறுப்புக்கும், 4 வது தனிமத்தின் குறிப்பை முந்தையதற்கும் மாற்றுவது மட்டுமே.

பட்டியலில் ஒரு உறுப்பு சேர்க்கப்படும் போது, ​​அதே செயல்முறை நடக்கும், ஆனால் தலைகீழாக.

வரிசைப்பட்டியலுடன் ஒப்பிடும்போது, ​​லிங்க்டுலிஸ்ட்டில் நாம் எவ்வளவு குறைவான வேலைகளைச் செய்ய வேண்டும் என்பதைக் கவனியுங்கள் . அது வெறும் 5 கூறுகள் தான். எங்கள் பட்டியலில் 100 அல்லது அதற்கு மேற்பட்ட கூறுகள் இருந்தால், LinkedList இன் மேன்மை இன்னும் கவனிக்கத்தக்கதாக இருக்கும்.

ஆனால் குறியீட்டின் மூலம் ஒரு உறுப்பை அணுகினால் நிலைமை எப்படி மாறும்?

இங்கே எல்லாம் நேர் எதிரானது.

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

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

இதையெல்லாம் பெரிய ஓ அடிப்படையில் வெளிப்படுத்த முயற்சிப்போமா?

குறியீட்டின் மூலம் ஒரு உறுப்பை அணுகுவதன் மூலம் தொடங்குவோம்.

ஒரு ArrayList இல் , பட்டியலில் உறுப்பு எங்கிருந்தாலும், இது ஒரு கட்டத்தில் நடக்கும். இறுதியில் அல்லது தொடக்கத்தில்.

இந்த வழக்கில், நேர சிக்கலானது O(1) ஆக இருக்கும் .

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

அத்தகைய செயலுக்கான நேர சிக்கலானது O(n) ஆகும் , இங்கு n என்பது நமக்குத் தேவையான தனிமத்தின் குறியீடாகும்.

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

ஷெல் அகற்றுவதற்கும் சேர்ப்பதற்கும் திரும்புவோம்?

LinkedList உடன் ஆரம்பிக்கலாம்.

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

ArrayList க்கான இந்த செயல்பாட்டின் நேர சிக்கலானது O(n) ஆகும் , இதை நாம் நேரியல் சிக்கலானது என்று அழைக்கிறோம்.

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

நேரம் சிக்கலானது மடக்கையாகவும் இருக்கலாம். இது O(log n) ஆக வெளிப்படுத்தப்படுகிறது .

உதாரணமாக, 10 எண்களைக் கொண்ட வரிசைப்படுத்தப்பட்ட ட்ரீசெட்டைக் கவனியுங்கள். நாங்கள் எண் 2 ஐக் கண்டுபிடிக்க விரும்புகிறோம்.

பட்டியல் வரிசைப்படுத்தப்பட்டிருப்பதாலும், பிரதிகள் இல்லாததாலும், அதை பாதியாகப் பிரித்து, எந்தப் பாதியில் விரும்பிய எண் இருக்கும் என்பதைச் சரிபார்த்து, பொருத்தமற்ற பகுதியை நிராகரித்து, விரும்பிய உறுப்பை அடையும் வரை இந்தச் செயல்முறையை மீண்டும் செய்யலாம். இறுதியில், log(n) உறுப்புகளின் எண்ணிக்கையைச் செயலாக்கிய பிறகு எண்ணைக் கண்டுபிடிப்போம் (அல்லது கண்டுபிடிக்கவில்லை).

மீதமுள்ள சேகரிப்புகளின் நேர சிக்கலைச் சுருக்கமாகக் கூறும் அட்டவணை இதோ.

பிரபலமான சேகரிப்புகளின் நேர சிக்கலைக் காட்டும் அட்டவணை இப்போது எங்களிடம் உள்ளது, பல சேகரிப்புகளில், நாங்கள் ஏன் பெரும்பாலும் ArrayList , HashSet மற்றும் HashMap ஐப் பயன்படுத்துகிறோம் என்ற கேள்விக்கு பதிலளிக்கலாம் .

பெரும்பாலான பணிகளுக்கு அவை மிகவும் திறமையானவை என்பது தான் :)