ஜாவாவில் இணைக்கப்பட்ட பட்டியல் தரவு அமைப்பு

வெவ்வேறு தரவு கட்டமைப்புகள் வெவ்வேறு நோக்கங்களுக்காக உருவாக்கப்படுகின்றன. ArrayList பற்றி நீங்கள் அறிந்திருக்கலாம் (இன்னும் இல்லையென்றால், அதைப் பற்றி முதலில் படிக்குமாறு பரிந்துரைக்கிறோம்). இந்தக் கட்டுரையில், LinkedList பற்றி அறிந்து கொள்ளப் போகிறோம் மற்றும் இந்தத் தொகுப்பு எதற்கு நல்லது என்பதை உணரப் போகிறோம். நீங்கள் LinkedList Java 8 (அல்லது மொழியின் பிற்கால பதிப்பு) வகுப்புக் குறியீட்டு மூலத்தைப் பார்த்தால் (Oracle இணையதளத்தில் அல்லது உங்கள் IDE இல், IDEA: வகுப்பின் பெயரில் crtl+B) நீங்கள் அடுத்த அறிவிப்பைக் காண்பீர்கள்:

public class LinkedList<E>
   extends AbstractSequentialList<E>
   implements List<E>, Deque<E>, Cloneable, java.io.Serializable

இந்த நேரத்தில், குறியீட்டின் மிக முக்கியமான தகவல் என்னவென்றால், லிங்க்ட்லிஸ்ட் பட்டியல் மற்றும் டீக் இடைமுகங்களை செயல்படுத்துகிறது . பட்டியல் இடைமுகம் உருப்படிகளைச் சேர்ப்பதற்கான வரிசையை வைத்திருக்கிறது மற்றும் குறியீட்டின் மூலம் உருப்படியை அணுக அனுமதிக்கிறது. "சாதாரண" வரிசை இறுதியில் கூறுகளைச் சேர்ப்பதை ஆதரிக்கிறது மற்றும் ஆரம்பத்தில் இருந்து அவற்றைப் பிரித்தெடுக்கிறது. Deque என்பது இருவழி வரிசையாகும், மேலும் இது இருபுறமும் உள்ள கூறுகளைச் சேர்ப்பதையும் அகற்றுவதையும் ஆதரிக்கிறது. ஸ்டாக் மற்றும் வரிசை ஆகியவற்றின் கலவையாக நீங்கள் நினைக்கலாம். எனவே, லிங்க்டுலிஸ்ட் என்பது இந்த இரண்டின் செயலாக்கமாகும், மேலும் இது பூஜ்ய உட்பட எந்தவொரு பொருளையும் கொண்ட இருதரப்பு வரிசையை உருவாக்க அனுமதிக்கிறது. இணைக்கப்பட்ட பட்டியல்உறுப்புகளின் தொகுப்பாகும். வகுப்பின் குறியீடு மூலத்தில் இதைப் பார்க்கலாம், இந்த முறை புலங்களுக்கு கவனம் செலுத்துங்கள்:

transient int size = 0;
/**
* Pointer to first node.
*/
transient Node<E> first;
/**
* Pointer to last node.
*/
transient Node<E> last;

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

இணைக்கப்பட்ட பட்டியல் கட்டமைப்பாளர்கள்

குறியீட்டு மூலத்திற்குத் திரும்பினால், LinkedList இல் இரண்டு கட்டமைப்பாளர்கள் இருப்பதைக் கண்டறியலாம்

• அளவுருக்கள் இல்லாத LinkedList() வெற்று பட்டியலை உருவாக்க பயன்படுகிறது.
• >LinkedList(தொகுப்பு<? நீட்டிக்கிறது E> c) என்பது குறிப்பிட்ட சேகரிப்பின் கூறுகளைக் கொண்ட பட்டியலை உருவாக்குவதற்காக, வரிசையாக, அவை சேகரிப்பின் மறுதொடக்கத்தால் வழங்கப்படும்.

இணைக்கப்பட்ட பட்டியல் அறிவிப்பு

உண்மையில், இணைக்கப்பட்ட பட்டியல் (ஜாவா அல்லது வேறு எந்த மொழியிலும்) முனைகளின் வரிசையைக் கொண்டுள்ளது. ஒவ்வொரு முனையும் உருவாக்கும் போது வரையறுக்கப்பட்ட ஒரு வகை பொருளை சேமிக்க வடிவமைக்கப்பட்டுள்ளது. எனவே LinkedList ஐ உருவாக்க , ஜாவா குறியீடு அடுத்தது:

LinkedList<Integer> myList = new LinkedList<>();

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

இணைக்கப்பட்ட பட்டியல் முக்கிய செயல்பாடுகள்

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

• add(E உறுப்பு) இந்தப் பட்டியலின் முடிவில் குறிப்பிட்ட உறுப்பைச் சேர்க்கிறது;
• add(int index, E உறுப்பு) குறிப்பிட்ட நிலை குறியீட்டில் உறுப்பைச் செருகுகிறது ;
• get(int index) இந்த பட்டியலில் குறிப்பிட்ட நிலையில் உள்ள உறுப்பை வழங்கும்;
• அகற்று(int index) நிலை குறியீட்டில் இருக்கும் உறுப்பை நீக்குகிறது;
• அகற்று(Object o) இன் முதல் நிகழ்வை நீக்குகிறது? இந்த பட்டியலில் உள்ள உறுப்பு இருந்தால்.
• remove() பட்டியலின் முதல் உறுப்பை மீட்டெடுத்து நீக்குகிறது.

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

நடைமுறையில் இந்த செயல்பாடுகளை முயற்சிப்போம். முதலில், ஜாவா லிங்க்டுலிஸ்ட் செயல்படுத்தல்: 3 கூறுகளைச் சேர்ப்பது, சரங்களின் லிங்க்ட் லிஸ்ட் உருவாக்குதல். பின்னர் ஒன்றை அகற்றவும், பின்னர் ஒன்றை நடுவில் சேர்க்கவும்.

public class MyLinkedTest {
   public static void main(String[] args) {
       String h1 = "my";
       String h2 = "favorite";
       String h3 = "book";
//  LinkedList implementation in Java
       LinkedList<String> linkedList = new LinkedList();
       linkedList.add(h1);
       linkedList.add(h2);
       linkedList.add(h3);
       System.out.println("my list after adding 3 elements:");
       System.out.println(linkedList);
       System.out.println("element #2 of my list:");
       System.out.println(linkedList.get(2));
       linkedList.remove(1);
       System.out.println("my list after removing #1:");
       System.out.println(linkedList);
       linkedList.add(1,"first");
       System.out.println("my list after adding an element in the middle");
       System.out.println(linkedList);
   }

இந்த நிரலை இயக்குவதன் விளைவு:

my list after adding 3 elements:
[my, favorite, book]
element #2 of my list:
book
my list after removing #1:
[my, book]
my list after adding an element in the middle
[my, first, book]

லிங்க்ட்லிஸ்ட் என்பது சேகரிப்பு கட்டமைப்பின் ஒரு பகுதியாகும் , உறுப்புகளை அகற்ற நீங்கள் இட்டரேட்டரைப் பயன்படுத்தலாம், அதே போல் பட்டியல்களுக்கான சிறப்பு மறு செய்கை - ListIterator . இன்னும் கூடுதலாக, இட்ரேட்டருடன் செயல்பாடுகள் லிங்க்ட்லிஸ்ட் வகுப்பின் முக்கிய நன்மைகளை வழங்குகின்றன : செருகல்/நீக்கு செயல்பாடுகளின் நல்ல செயல்திறன். இட்டரேட்டரைப் பயன்படுத்தி, நீங்கள் அவர்களுக்கு நிலையான நேரத்தைப் பெறலாம். இந்தக் கட்டுரையில் பின்னர், ArrayList மற்றும் LinkedList+Iterator ஆகியவற்றை ஒப்பிடுவதற்கு ஒரு குறியீட்டு உதாரணத்தை எழுதுவோம்.

• Iterator.remove() ஆனது இந்த மறு செய்கையால் வழங்கப்பட்ட கடைசி உறுப்பை நீக்குகிறது.
• ListIterator.add(E உறுப்பு) பட்டியலில் ஒரு உறுப்பைச் செருகுகிறது

Java LinkedList எடுத்துக்காட்டு: இட்டரேட்டர் எவ்வாறு செயல்படுகிறது

இங்கே எங்களிடம் ஒரு சிறிய ஜாவா லிங்க்டுலிஸ்ட் எடுத்துக்காட்டு குறியீடு உள்ளது, அங்கு இட்டரேட்டர் மூலம் சேர்க்க மற்றும் நீக்க முயற்சிக்கிறோம்.

public class MyLinkedTest {
   public static void main(String[] args) {
       String h1 = "my";
       String h2 = "favorite";
       String h3 = "book";
       LinkedList<String> linkedList = new LinkedList();
       linkedList.add(h1);
       linkedList.add(h2);
       linkedList.add(h3);
 
       Iterator i = linkedList.iterator();
       String str = "";
       while (i.hasNext()) {
           str = (String)i.next();
           if (str.equals("favorite")) {
               i.remove();
               break;
           }
       }

       System.out.println("linkedList after removing element via Iterator:");
       System.out.println(linkedList);
       ListIterator listIterator = linkedList.listIterator();
       listIterator.add("I've got");
       System.out.println("linkedList after adding the element via ListIterator");
       System.out.println(linkedList);
 
   }
}

இந்த நிரலை இயக்குவதன் விளைவு:

linkedList after removing element via Iterator:
[my, book]
linkedList after adding the element via ListIterator
[I've got, my, book]

மேலும் ஜாவா இணைக்கப்பட்ட பட்டியல் செயல்பாடுகள்:

• addFirst() , addLast() பட்டியலின் ஆரம்பம்/முடிவில் ஒரு உறுப்பைச் சேர்க்கவும்
• clear() பட்டியலிலிருந்து அனைத்து கூறுகளையும் நீக்குகிறது
• பட்டியலானது o உறுப்பைக் கொண்டிருந்தால், contains(Object o) உண்மை என்பதைத் தரும்.
• indexOf(Object o) ஆனது o உறுப்பின் முதல் நிகழ்வின் குறியீட்டை அல்லது பட்டியலில் இல்லை என்றால் -1 ஐ வழங்கும்.
• தொகுப்பு (int index, E உறுப்பு) குறியீட்டு நிலையில் உள்ள உறுப்பை உறுப்புடன் மாற்றுகிறது
• அளவு() பட்டியலில் உள்ள உறுப்புகளின் அளவை வழங்குகிறது.
• toArray() ஆனது பட்டியலின் அனைத்து உறுப்புகளையும் முதல் முதல் கடைசி உறுப்பு வரை கொண்ட ஒரு வரிசையை வழங்குகிறது.

BTW இரண்டு அளவிலான வரிசையாக இருப்பதால், ஜாவாவில் உள்ள LinkedList குறிப்பிட்ட செயல்பாடுகளை அடுக்கி வைத்துள்ளது:

• பாப்() அடுக்கில் இருந்து ஒரு உறுப்பைத் தோன்றும் (பட்டியலினால் குறிப்பிடப்படுகிறது)
• புஷ்(E e) இது ஒரு உறுப்பை அடுக்கின் மீது தள்ளும் (இந்தப் பட்டியலில் குறிப்பிடப்படுகிறது)

இணைக்கப்பட்ட பட்டியலை மாற்றுவது எப்படி: உதாரணம்

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

public class MyLinkedTest {
   public static void main(String[] args) {
       String h1 = "my";
       String h2 = "favorite";
       String h3 = "book";
       LinkedList<String> linkedList = new LinkedList();
       linkedList.add(h1);
       linkedList.add(h2);
       linkedList.add(h3);
       System.out.println(linkedList);
       System.out.println("Reversed LinkedList:");
       System.out.println(reverseLinkedList(linkedList));
   }
   public static LinkedList<String> reverseLinkedList(LinkedList<String> list)
   {
       LinkedList<String> LinkedList = new LinkedList<String>();
       for (int i = list.size() - 1; i >= 0; i--) {
           LinkedList.add(list.get(i));
       }
       return LinkedList;
   }
}

முடிவு:

[I've got, my, book]
Reversed LinkedList:
[book, my, I've got]

LinkedList vs ArrayList: முதல் ஒன்றை எப்போது பயன்படுத்த வேண்டும்

LinkedList மற்றும் ArrayList இரண்டும் பட்டியல் இடைமுகத்தின் செயலாக்கங்கள் . LinkedList அதை இரட்டை இணைக்கப்பட்ட பட்டியலுடன் செயல்படுத்துகிறது. அரேலிஸ்ட் அதை மாறும் மறுஅளவிடல் வரிசையைப் பயன்படுத்தி செயல்படுத்துகிறது. உங்களுக்கு ஏற்கனவே தெரியும், LinkedList இன் ஒவ்வொரு முனையிலும் பொருள்கள் மற்றும் அண்டை நாடுகளுக்கான இரண்டு குறிப்புகள் உள்ளன. அதாவது Java LinkedList வழக்கில் உள்ள உறுப்புகளுக்கு இடையே குறிப்புகளை சேமிப்பதற்கான கூடுதல் நினைவக செலவுகள் . ArrayList அதை ஒரு மாறும் மறுஅளவிடல் வரிசையுடன் செயல்படுத்துகிறது. சில LinkedList மற்றும் ArrayList செயல்பாடுகள் ஒரே மாதிரியாக இருக்கும், ஆனால் அவை வேறு வழியில் செயல்படுகின்றன. வரிசைப்பட்டியலில் _வழக்கில், நீங்கள் உள் அணிவரிசைகளைக் கையாளுகிறீர்கள், LinkedList இல் — குறிப்புகளுடன். ArrayList மிகவும் பிரபலமான பட்டியல் செயல்படுத்தல் ஆகும். இந்த செயல்பாடுகள் நிலையான நேரத்தில் செய்யப்படுவதால், குறியீட்டு அணுகல் முன்னுரிமையாக இருக்கும்போது நீங்கள் நிச்சயமாக ArrayList ஐப் பயன்படுத்த வேண்டும். சராசரியாக பட்டியலின் முடிவில் சேர்ப்பதும் நிலையான நேரத்தில் செய்யப்படுகிறது. இன்னும் கூடுதலாக, ArrayList க்கு ஒரு சில கூறுகளை சேமிப்பதற்கான கூடுதல் செலவுகள் இல்லை. பட்டியலின் முடிவில் இல்லாத போது, ​​செருகும் மற்றும் அகற்றும் செயல்பாடுகளின் வேகத்தை நீங்கள் பாதகமாக எண்ணலாம். இணைக்கப்பட்ட பட்டியல்சில வழிகளில் செயல்பாடுகளைச் செருகுதல் மற்றும் நீக்குதல் ஆகியவற்றின் போது மிகவும் பயனுள்ளதாக இருக்கும்: நீங்கள் மறு செய்கைகளைப் பயன்படுத்தினால் அது நிலையான நேரத்தில் நிகழ்கிறது. குறியீட்டின் மூலம் அணுகல் செயல்பாடுகள் முடிவின் தொடக்கத்திலிருந்து (எது அருகில் உள்ளதோ) விரும்பிய உறுப்புக்குத் தேடுவதன் மூலம் செய்யப்படுகிறது. இருப்பினும், உறுப்புகளுக்கு இடையில் குறிப்புகளை சேமிப்பதற்கான கூடுதல் செலவுகள் பற்றி மறந்துவிடாதீர்கள். எனவே இங்கே நிலையான LinkedList மற்றும் ArrayList செயல்பாடுகள் அல்காரிதம் இயக்க நேரங்களுடன். N என்பது ஏற்கனவே பட்டியலில் உள்ள உருப்படிகளின் எண்ணிக்கையைக் குறிக்கிறது. O(N) என்பது, மோசமான நிலையில், தேவையான நிலையைக் கண்டறியும் வரை முழுப் பட்டியலிலும் "நடக்க" வேண்டும், எடுத்துக்காட்டாக, பட்டியலில் புதிய உறுப்பைச் செருகுவதற்கு. O(1)செயல்பாடு நிலையான நேரத்தில், பொருட்களின் எண்ணிக்கையில் சுயாதீனமாக நடக்கிறது என்று அர்த்தம்.

இணைக்கப்பட்ட பட்டியல் நேர சிக்கலானது

வரிசைப்பட்டியல் நேர சிக்கலானது

இணைப்புப்பட்டியலை எப்போது பயன்படுத்த வேண்டும்: எடுத்துக்காட்டு

நிச்சயமாக, ArrayList மிகவும் பிரபலமான பட்டியல் செயல்படுத்தல் ஆகும். இருப்பினும், அடிக்கடி சேர்க்கும்/அகற்றும் செயல்பாடுகள் தேவைப்படும் சூழ்நிலைகளை நீங்கள் சந்திக்கலாம். அப்படியானால், இட்டரேட்டருடன் லிங்க்டுலிஸ்ட் அனைத்தும் நன்மை பயக்கும். இதோ ஒரு உதாரணம். எங்களிடம் ஒரு நீண்ட பட்டியல் உள்ளது, இந்த பட்டியலிலிருந்து ஒவ்வொரு உறுப்புகளையும் நீக்க வேண்டும். ArrayList மற்றும் LinkedList + Iterator மூலம் இந்தப் பணியைச் செய்வோம் . ஒவ்வொரு செயல்பாட்டின் நேரத்தையும் ஒப்பிட்டு கன்சோலில் அச்சிடுகிறோம். இங்கே குறியீடு:

import java.util.*;
import java.util.function.BiPredicate;
 
public class ListTest2 {
 
   static void removeElements(List<Double> list, BiPredicate<Integer, Double> predicate) {
       // start navigation from end to preserve indexes of removed items
       ListIterator<Double> iterator = list.listIterator(list.size());
 
       while (iterator.hasPrevious()) {
           Double element = iterator.previous();
           if (predicate.test(iterator.previousIndex()+1, element)) {
               iterator.remove();
           }
       }
   }
 
   static class TestCase1 {
       public static void main(String[] args) {
           LinkedList<Double> testedList1 = new LinkedList<>(Arrays.asList(2.0,9.0,3.0,12.0,5.0));
           removeElements(testedList1, (index, value) -> (value % 3 == 0));
           // should print `[2.0, 5.0]`
           System.out.println("testedList1 after removeElements(..): " + testedList1);
 
           ArrayList<Double> testedList2 = new ArrayList<>(Arrays.asList(2.0,9.0,3.0,12.0,5.0));
           removeElements(testedList2, (index, value) -> (value % 3 == 0));
           // should print `[2.0, 5.0]`
           System.out.println("testedList2 after removeElements(..): " + testedList2);
       }
   }
 
   static class TestLinkedListPerformance {
       public static void main(String[] args) {
           LinkedList<Double> testedList = new LinkedList<>();
           System.out.println("start filling testedList");
           for (int i = 0; i < 2 * 1000 * 1000 ; ++i) {
               testedList.add((double)i);
           }
 
           System.out.println("start treating testedList");
           long startTime = System.nanoTime();
           removeElements(testedList, (index, value) -> (value % 3 == 0));
           long endTime = System.nanoTime();
           // should print `1333333`
           System.out.println("testedList.size after removeElements(..): " + testedList.size());
           // could print `0.1527659`
           System.out.println("removeElements(..) takes (seconds): " + ((double)(endTime - startTime)) / 1000000000);
       }
   }
 
   static class TestArrayListPerformance {
       public static void main(String[] args) {
           ArrayList<Double> testedList = new ArrayList<>();
           System.out.println("start filling testedList");
           for (int i = 0; i < 2 * 1000 * 1000 ; ++i) {
               testedList.add((double)i);
           }
 
           System.out.println("start treating testedList");
           long startTime = System.nanoTime();
           removeElements(testedList, (index, value) -> (value % 3 == 0));
           long endTime = System.nanoTime();
           // should print `1333333`
           System.out.println("testedList.size after removeElements(..): " + testedList.size());
           // could print `53.4952635`
           System.out.println("removeElements(..) takes (seconds): " + ((double)(endTime - startTime)) / 1000000000);
       }
   }
}

வரிசைப்பட்டியலுக்கான முடிவுகள்:

start filling testedList
start treating testedList
testedList.size after removeElements(..): 1333333
removeElements(..) takes (seconds): 481.8824414

இணைப்புப்பட்டியலுக்கான முடிவுகள்:

start filling testedList
start treating testedList
testedList.size after removeElements(..): 1333333
removeElements(..) takes (seconds): 0.4586458

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

AddOn: Singly Linked List Java

ஜாவாவில் கிளாசிக்கல் சேகரிப்பில் ஒற்றை இணைக்கப்பட்ட பட்டியல் இல்லை , Singly Linked List என்பது ஒவ்வொரு முனையிலும் ஒரு பொருளையும் அடுத்த முனைக்கான குறிப்பையும் கொண்டிருக்கும் ஒரு கட்டமைப்பாகும், ஆனால் முந்தையது அல்ல. Java LinkedList இரண்டு-இணைக்கப்பட்டுள்ளது, ஆனால் Singly ,code>Linked List போன்ற உங்களின் சொந்த தரவு கட்டமைப்பை உருவாக்க யாரும் உங்களுடன் குறுக்கிட மாட்டார்கள். இந்த பணிகளை தீர்க்க சில படிகள் இங்கே:

1. தரவு மற்றும் அடுத்தது என இரண்டு பண்புக்கூறுகளுடன் ஒரு நோட் வகுப்பை உருவாக்கவும் . அடுத்தது அடுத்த முனைக்கு ஒரு குறிப்பு.
2. தலை மற்றும் வால் ஆகிய இரண்டு பண்புகளுடன் FirstLast வகுப்பை உருவாக்கவும் .
3. பட்டியலில் புதிய முனையைச் சேர்க்க add() முறையை உருவாக்கவும் . பட்டியல் காலியாக உள்ளதா என்பதை முதலில் சரிபார்க்கவும் ( தலை == பூஜ்யம் ). அப்படியானால், தலை மற்றும் வால் புதிய முனையைக் குறிக்கும். பட்டியல் காலியாக இல்லாவிட்டால், புதிய முனை இறுதியில் சேர்க்கப்படும், எனவே வால் அடுத்த பண்புக்கூறு சேர்க்கப்பட்ட முனையைக் குறிக்கிறது மற்றும் புதிய முனை பட்டியலின் வாலாக மாறும்.

உங்கள் சொந்த லிங்க்டுலிஸ்ட்டையும் ஒரு பயிற்சியாக உருவாக்க முயற்சி செய்யலாம் . உங்கள் கற்றலில் நல்ல அதிர்ஷ்டம்.