அடுக்கு, வரிசை குறித்துக் கடந்த அத்தியாயத்தில் பார்த்தோம். தரவுகளைச் சேமிப்பது, அதைத் திரும்ப அணுகுவது போன்றவற்றில் அடுக்கிற்கும், வரிசைக்கும் இடையே உள்ள வேறுபாட்டை நிரல் எழுதி புரிந்துகொண்டோம். ஆனால் அவை எங்கே பயன்படுகின்றன என்று தெரிந்துகொள்வதும் அவசியம் தான், இல்லையா? நிரலாக்க மொழியில் நாம் பயிலும் தலைப்புகளைக் கொண்டு ஒரு சிக்கலுக்கு எப்படித் தீர்வு காண முடிகிறது என்பதைப் பயிற்சி செய்து பார்க்காத வரைக்கும், நமது கற்றல் முழுமை அடைவதில்லை. எனவே முறையே அடுக்கும் வரிசையும் எங்கே அப்படி பிரச்சனைகளைக் கையாள்கின்றன என்பது குறித்துப் பார்த்துவிடுவோம்.
நிரல் 1: கணிதக் கோவையை மதிப்பீடு செய்தல்
ஒரு கணிதக் கோவை பின்னொட்டு குறிமானமாக (Postfix Notation) எழுதப்பட்டுள்ளது. அவற்றை அடுக்கில் சேமித்து அதற்கான விடையைக் கண்டறிவது தான் இந்நிரலின் நோக்கம்.
பின்னொட்டு குறிமானம் என்றால் என்ன?
அடைப்புக்குறிகளின் தேவையின்றி கணிதக் கோவையில் உள்ள எண்கள் முதலிலும், அவற்றைத் தொடர்ந்து கணித இயக்கிகளும் இடம்பெற்றிருந்தால் பின்னொட்டு குறிமானம் அடிப்படையில் குறிப்பிட்ட கணிதக் கோவை எழுதப்பட்டுள்ளது என்று அர்த்தம்.
எதற்காக இப்படியொரு ஏற்பாடு?
போட்மாஸ்(BODMAS) விதியின் அடிப்படையில் கணிதக் கோவைகளை மதிப்பீடு செய்து விடையைக் கண்டறிவதற்காக இப்படியொரு ஏற்பாடு. உதாரணத்திற்கு நிரலில் பயன்படுத்தப்பட்டுள்ள “2 3 4 * +” என்ற கணிதக் கோவையை எடுத்துக்கொள்வோம்.
அடுக்கில் தரவுகள் தயாராக இருக்கின்றன. இனி நிரல் …
stack=[] என்ற பட்டியலை உருவாக்கி அதில் கணிதக் கோவையில் உள்ள ஒவ்வொரு உறுப்பாக இணைத்துக்கொள்ள இருக்கிறோம். “2 3 4 * +” என்ற கணிதக் கோவை சரம் த.வகையாக அனுப்பப்படுகின்றது.
சரத்தில் உள்ள இடைவெளியைக் கண்டறிந்து அதற்கு முன்பிருக்கும் உறுப்பை(களை)ப் பிரிக்க வல்லது split() மு.வ.செயல்பாடு. எனவே அதனைக்கொண்டு கோவையில் உள்ள ஒவ்வொரு உறுப்பாகப் பிரித்து எடுக்கிறோம். இதனைச் செய்துமுடிக்க எப்போதும் போல நமக்கு for loop உதவி செய்கிறார்.
கணிதக் கோவையில் முதலாவதாக என்ன இருக்கிறது பாருங்கள், ‘2’ ஒரு இலக்கமா என்று நிரலைக் கேட்கிறோம், ஆம் இலக்கமே தான். எனில் அதை முழு எண்ணாக மாற்றி அடுக்கில் சேமிக்கிறோம். அடுத்ததாக ‘3’ ஒரு இலக்கம் தானா என்று மேலும் பரிதாபமாக நிரலைப் பார்த்துக் கேட்கிறோம். ஆம் தானே, அதிலென்ன சந்தேகம். ‘3’ஐ முழு எண்ணாக மாற்றி அடுக்கில் இணைக்கிறோம். நிறைவாக, 4கிற்கும் அதே கதை தான். ஆக, அடுக்கு பின்வருமாறு தோற்றம் கொண்டிருக்கும்
4
3
2
இப்போது நிரலின் அடுத்த பகுதிக்கு நகர்கிறோம். இனி கோவையில் இலக்கங்கள் இல்லை, இயக்கிகள் தான். இயக்கியை நிரல் எதிர்கொள்ளும் பொழுது, அடுக்கில் உள்ள முதலிரண்டு இலக்கங்களையும் pop()ஐ பயன்படுத்தி வெளியே எடுக்கிறோம்.
4ம், 3ம் வெளியேறி விடுகின்றன. இப்போது என்ன இயக்கி கோவையில் வருகிறது என்று பாருங்கள், ‘*” தான் இல்லையா? முதல்கட்டமாகப் பின்வருமாறு கோவை மதிப்பீடு செய்யப்படுகின்றது
4 * 3 -> 12. கிடைத்த விடையையும் அடுக்கில் இணைக்கிறோம். இப்போது அடுக்கின் தோற்றம் இவ்வாறு இருக்கும்
12
2
கோவையில் நிறைவாக இடம்பெற்றிருக்கும் இயக்கி ‘+’, ஒரு இயக்கியைக் காண நேர்ந்தால் அடுக்கில் உள்ள முதலிரண்டு இலக்கங்கள் வெளியேறும். பின்வருமாறு கோவை மதிப்பீடு செய்யப்படும்
12 + 2 -> 14, இறுதியாக விடை அடுக்கில் சேமிக்கப்படுகின்றது.
விடை சரி தானா என்று பார்ப்போமா?
“2 3 4 * +”
14 என்பது மிகச் சரியான விடை.
அடுக்கு எனும் தரவு கட்டமைப்பு ஒரு கணித கோவையை மதிப்பீடு செய்ய எவ்வாறு உதவுகிறது என்பது இதன்மூலம் தெளிவாகிறது. மேலும் அடுக்கு த.கட்டமைப்பு விளையாட்டுகளில் முந்தைய நகர்வைத் தொடர்ச்சியாகச் சேமிக்கவும் பயன்படுகிறது.
தொடரை வாசிப்பவர்கள் ஒரு எளிமையான விளையாட்டின் நகர்வுகளை அடுக்கு த.கட்டமைப்பு எவ்வாறு சேமிக்கிறது என்பதற்கு ஒரு நிரல் எழுதும் பட்சத்தில், அது ஒப்பற்ற பயிற்சியாக இருக்கும்.
நிரல் 2: பணிகளைச் செய்துமுடித்தல்
கணினியிடமோ அல்லது அதனுடன் இணைக்கப்பட்டிருக்கும் பிரிண்டரிடமோ உடனடியாக செய்து தரும்படி ஒரே நேரத்தில் மூன்று வேலைகளைத் தருகிறீர்கள். முதலில் செய்து முடிக்க வேண்டிய வேலையை அவை எதன் அடிப்படையில் தேர்ந்தெடுக்கும்?
“இதென்னப்பா கேள்வி? யார் முதலில் வருகிறார்களோ அவர்களுக்குத்தான். அதானே உலக வழக்கம்” என்பவர்கள் தொடர்ந்து படிக்கவும்.
ஆக முதலில் வருபவர்களுக்கே முன்னுரிமை என்று சத்தியம் செய்து கொள்கையோடு வாழும் தரவு கட்டமைப்பு வரிசை. அதைப் பயன்படுத்தியே பின்வரும் நிரலை எழுத இருக்கிறோம்.
Task 1, Task 2, Task 3 என்ற மூன்று வேலைகளை உருவாக்கி நிரலுக்குத் தருகிறோம். அவை முறையே பட்டியலில் பின்வருமாறு சேமிக்கப்படுகின்றன
[Task 1, Task 2, Task 3]
நம் புரிதலுக்காக இப்படியும் எழுதிக்கொள்ளலாம்
Task 1
Task 2
Task 3
இப்போது முதலில் வந்தவர் யார்? Task 1, எனில் அவர் தான் முதலில் வெளியே(வேலையை முடித்து) அனுப்பப்பட வேண்டும். பட்டியல் தரும் pop() செயல்பாட்டுக்கு அளவுரு தராத பட்சத்தில், பட்டியலின் கடைசி உறுப்பை நீக்கித்தரும். இந்த நுட்பம் அடுக்கு த.கட்டமைப்பை உருவாக்கப் பெரிதும் உதவியது.
இங்கே நாம் உருவாக்க இருப்பது வரிசையை. அதாவது சதா முதலில் வருபவரைப் பற்றியே யோசிப்பது. பட்டியலைக் கொண்டுதான் அனைத்து மேம்பட்ட தரவு கட்டமைப்புகளை உருவாக்குகிறோம். எனில் பட்டியலில் முதலில் இணையும் உறுப்பின் நேர் குறியீட்டு எண் என்னவாக இருக்கும்?
மிகச்சரி, 0 தான். எனவே அளவுரு இல்லாமல் இருப்பதற்குப் பதிலாக, pop(0) என்று தருகிறோம். இதன்மூலம் வரிசையில் முதலில் உள்ள உறுப்பே முதலில் வெளியேறுவதை உறுதி செய்கிறோம். இதன்மூலம் வரிசை வெற்றிகரமாக உருவாக்கப்படுகிறது. மேலும் வேலைகள் அவை ஒப்படைக்கப்பட்ட வரிசையில் செய்தும் முடிக்கப்படுகின்றன.
அடுக்கு வரிசை போல இன்னமும் சில சுவாரசியமான மேம்பட்ட தரவு கட்டமைப்புகள்(எல்லா நிரலாக்க மொழிகளுக்கும் பொதுவான) பைத்தானிலும் உள்ளன. அவற்றை எதிர்வரும் அத்தியாயங்களில் காண்போம்.
(தொடரும்)
