𝗙𝗿𝗼𝗻𝘁𝗲𝗻𝗱 𝗟𝗶𝗻𝗲𝗮𝗿 𝗗𝗮𝘁𝗮 𝗦𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝘀
நேரியல் தரவு அமைப்புகள் (Linear data structures) உறுப்புகளை ஒரு வரிசையில் அடுக்குகின்றன. ஒவ்வொரு உறுப்பிற்கும் ஒரு முன்னைய உறுப்பும் (predecessor) ஒரு பிந்தைய உறுப்பும் (successor) இருக்கும்.
Arrays Arrays என்பவை JavaScript-இல் உள்ள முக்கிய கருவியாகும். இவை தொடர்ச்சியான நினைவகத்தைப் (contiguous memory) பயன்படுத்துகின்றன. இது எந்தவொரு உறுப்பையும் அதன் குறியீட்டின் (index) மூலம் உடனடியாக அணுக அனுமதிக்கிறது.
- push: இறுதியில் ஒரு உறுப்பைச் சேர்க்கிறது.
- unshift: தொடக்கத்தில் ஒரு உறுப்பைச் சேர்க்கிறது. மற்ற அனைத்து உறுப்புகளும் ஒரு இடத்திற்கு வலதுபுறம் நகர வேண்டியிருப்பதால் இது மெதுவானது.
- splice: எந்த இடத்திலும் உறுப்புகளைச் சேர்க்கலாம் அல்லது நீக்கலாம். இந்த முறை அசல் array-ஐ மாற்றுகிறது. இது ஒரு pure function அல்ல.
குறிப்பு: ஒரு array மிகப் பெரியதாக வளரும்போது, JavaScript ஒரு பெரிய நினைவகத் தொகுதியை (memory block) ஒதுக்கீடு செய்து அனைத்தையும் அங்கு நகலெடுக்க வேண்டும். இது செயல்திறனைப் (performance) பாதிக்கும்.
Stacks Stack என்பது LIFO விதியைப் பின்பற்றுகிறது: Last In, First Out (கடைசியாக வருவது முதலில் வெளியேறும்). தட்டுகளின் குவியலை நினைவில் கொள்ளுங்கள். நீங்கள் மேலிருந்து மட்டுமே சேர்க்கவோ அல்லது நீக்கவோ முடியும்.
- push: மேலே சேர்க்கிறது.
- pop: மேலிருந்து நீக்குகிறது.
- peek: மேலிருக்கும் உறுப்பை நீக்காமல் அதைப் பார்க்கிறது.
Queues Queue என்பது FIFO விதியைப் பின்பற்றுகிறது: First In, First Out (முதலில் வருவது முதலில் வெளியேறும்). ஒரு கடையில் உள்ள வரிசையை நினைவில் கொள்ளுங்கள்.
- push: பின்புறம் சேர்க்கிறது.
- shift: முன்புறத்திலிருந்து நீக்குகிறது.
எச்சரிக்கை: பெரிய தரவுத் தொகுதிகளுக்கு (datasets) ஒரு array-இல் shift முறையைப் பயன்படுத்துவது மெதுவானது. இடைவெளியை நிரப்ப ஒவ்வொரு உறுப்பும் இடதுபுறம் நகர வேண்டும். அதிக அளவிலான தரவுகளுக்கு, அதற்குப் பதிலாக ஒரு linked list-ஐப் பயன்படுத்தவும்.
Linked Lists A linked list என்பது nodes-களால் ஆனது. ஒவ்வொரு node-உம் தரவையும் (data) அடுத்த node-க்கான ஒரு pointer-ஐயும் கொண்டுள்ளது.
- நன்மைகள்: நீங்கள் சரியான இடத்தைக் கண்டறிந்தவுடன், nodes-களைச் சேர்ப்பது அல்லது நீக்குவது வேகமானது. நீங்கள் pointer-களை மட்டுமே மாற்ற வேண்டும்.
- தீமைகள்: நீங்கள் ஒரு குறிப்பிட்ட index-க்கு நேரடியாகச் செல்ல முடியாது. நீங்கள் head-இல் தொடங்கி, ஒவ்வொரு pointer-ஐயும் ஒவ்வொன்றாகப் பின்தொடர வேண்டும். இது மெதுவானது.
Comparison Summary:
- Arrays: அடிக்கடி வாசிப்பதற்கும் (reads) சிறிய தரவுகளுக்கும் சிறந்தது. அணுகுதல் (Access) O(1).
- Linked Lists: அடிக்கடி எழுதுவதற்கும் (writes) பெரிய தரவுகளுக்கும் சிறந்தது. உங்களிடம் node இருந்தால், சேர்த்தல் (Insertion) O(1).
Pro Tips for JavaScript:
- ஒரு array-இல் வெவ்வேறு தரவு வகைகளை (data types) கலக்க வேண்டாம். வகைகளை ஒரே மாதிரியாக வைத்திருப்பது, engine தொடர்ச்சியான நினைவகத்தைப் பயன்படுத்த உதவும்.
- எண்களை வரிசைப்படுத்தும் போது (sorting) எப்போதும் ஒரு comparator function-ஐப் பயன்படுத்தவும். [10, 2].sort() என்பது [10, 2] என்ற முடிவைத் தரும், ஏனெனில் அது சரங்களாக (strings) வரிசைப்படுத்துகிறது.
- பெரும்பாலான native array முறைகள் அசல் array-ஐ மாற்றியமைக்கும் (mutate) என்பதை நினைவில் கொள்ளுங்கள்.