ජාවා හි අරේලිස්ට් හරහා LinkedList භාවිතා කරන්නේ කවදාද?

මම සැමවිටම සරලව භාවිතා කළ අයෙක්:

List<String> names = new ArrayList<>();

මම වර්ගය නම ලෙස එම අතුරුමුහුණත භාවිත පහසුවෙන් එහාමෙහා ගෙන යාමේ මම මේ වගේ ප්රශ්න ඇසීමට විට මම මගේ කේතය ලෙස කා වැද්දීමට හැකි නිසා බව,.

LinkedListනැවත නැවතත් භාවිතා කළ යුත්තේ කවදාද ArrayList?

සාරාංශය ArrayList සමග ArrayDequeදී වඩාත් වේ බොහෝ වඩා භාවිතා-නඩු LinkedList. ඔබට විශ්වාස නැත්නම් - ආරම්භ කරන්න ArrayList.

LinkedListසහ ArrayListලැයිස්තු අතුරුමුහුණතේ වෙනස් ක්‍රියාත්මක කිරීම් දෙකක් වේ. LinkedListඑය ද්විත්ව සම්බන්ධිත ලැයිස්තුවක් සමඟ ක්‍රියාත්මක කරයි. ArrayListගතිකව නැවත ප්‍රමාණයේ අරාවකින් එය ක්‍රියාත්මක කරයි.

සම්මත සම්බන්ධිත ලැයිස්තුව සහ අරාව මෙහෙයුම් වලදී මෙන්, විවිධ ක්‍රමවලට විවිධ ඇල්ගොරිතම ධාවන වේලාවන් ඇත.

සදහා LinkedList<E>

• get(int index)වන සාමාන්ය (n) (සමග n / 4 සාමාන්යයෙන් පියවර), නමුත් සාමාන්ය (1) වන විට index = 0හෝ index = list.size() - 1(මේ අවස්ථාවේ දී, ඔබ ද භාවිතා කළ හැකිය getFirst()සහ getLast()). හි ප්රධාන වාසි වලින් එකක් LinkedList<E>
• add(int index, E element)වන සාමාන්ය (n) (සමග n / 4 සාමාන්යයෙන් පියවර), නමුත් සාමාන්ය (1) වන විට index = 0හෝ index = list.size() - 1(මේ අවස්ථාවේ දී, ඔබ ද භාවිතා කළ හැකිය addFirst()සහ addLast()/ add()). හි ප්රධාන වාසි වලින් එකක් LinkedList<E>
• remove(int index)වන සාමාන්ය (n) (සමග n / 4 සාමාන්යයෙන් පියවර), නමුත් සාමාන්ය (1) වන විට index = 0හෝ index = list.size() - 1(මේ අවස්ථාවේ දී, ඔබ ද භාවිතා කළ හැකිය removeFirst()සහ removeLast()). හි ප්රධාන වාසි වලින් එකක් LinkedList<E>
• Iterator.remove()වන දෙවියනි, (1) . හි ප්රධාන වාසි වලින් එකක් LinkedList<E>
• ListIterator.add(E element)වන දෙවියනි, (1) . හි ප්රධාන වාසි වලින් එකක් LinkedList<E>

^{සටහන: බොහෝ මෙහෙයුම් සඳහා සාමාන්‍යයෙන් n / 4 පියවර, හොඳම අවස්ථාවෙහි නියත පියවර ගණන (උදා: දර්ශකය = 0), සහ නරකම අවස්ථාවක n / 2 පියවර (ලැයිස්තුවේ මැද)}

සදහා ArrayList<E>

• get(int index)වන දෙවියනි, (1) . ප්රධාන ප්රතිලාභය ArrayList<E>
• add(E element)වන දෙවියනි, (1) ක්රමක්ෂය, නමුත් සාමාන්ය (n) අරාව ප්රථිප්රමාණය සහ පිටපත් කළ යුතුය සිට නරකම
• add(int index, E element)වන සාමාන්ය (n) (සමග n / 2 සාමාන්ය පියවර)
• remove(int index)වන සාමාන්ය (n) (සමග n / 2 සාමාන්ය පියවර)
• Iterator.remove()වන සාමාන්ය (n) (සමග n / 2 සාමාන්ය පියවර)
• ListIterator.add(E element)වන සාමාන්ය (n) (සමග n / 2 සාමාන්ය පියවර)

^{සටහන: මෙහෙයුම් බොහෝ අවශ්ය n / 2 සාමාන්ය මත පියවර නිරන්තර හොඳම නඩුව (ලැයිස්තුවේ අවසානය) පියවර සංඛ්යාව, n නරකම (ලැයිස්තුව ආරම්භයක්) පියවර}

LinkedList<E>iterator භාවිතා කරමින් නියත-කාලීන ඇතුළත් කිරීම් හෝ ඉවත් කිරීම් සඳහා ඉඩ ලබා දේ , නමුත් මූලද්‍රව්‍යවල අනුක්‍රමික ප්‍රවේශය පමණි. වෙනත් වචන වලින් කිවහොත්, ඔබට ලැයිස්තුව ඉදිරියට හෝ පසුපසට ගමන් කළ හැකිය, නමුත් ලැයිස්තුවේ ස්ථානයක් සොයා ගැනීම ලැයිස්තුවේ ප්‍රමාණයට සමානුපාතික වේ. ජාවඩොක් පවසන්නේ “ලැයිස්තුවට දර්ශක කරන මෙහෙයුම් ආරම්භයේ සිට අවසානය දක්වා, කුමන දෙයට වඩා සමීපද යන්න” , එබැවින් එම ක්‍රම සාමාන්‍යයෙන් O (1) වුවද O ( n) ( n / 4 පියවර ) වේ index = 0.

ArrayList<E>, අනෙක් අතට, වේගවත් අහඹු කියවීමේ ප්‍රවේශයට ඉඩ දෙන්න, එවිට ඔබට ඕනෑම මූලද්‍රව්‍යයක් නියත වේලාවක ලබා ගත හැකිය. නමුත් ඕනෑම තැනකින් එකතු කිරීම හෝ ඉවත් කිරීම, නමුත් අවසානයට අවශ්‍ය වන්නේ පසු විපරම් කරන ලද සියලුම මූලද්‍රව්‍යයන් විවෘත කිරීම හෝ පරතරය පිරවීම ය. එසේම, ඔබ යටින් පවතින අරාවේ ධාරිතාවට වඩා වැඩි මූලද්‍රව්‍යයක් එකතු කරන්නේ නම්, නව අරාවක් (ප්‍රමාණය මෙන් 1.5 ගුණයක්) වෙන් කර ඇති අතර, පැරණි අරාව නව ඒවාට පිටපත් කරනු ලැබේ, එබැවින් O (n) ට එකතු කිරීම නරකම ArrayListදෙයකි නඩුව නමුත් සාමාන්‍යයෙන් නියතයි.

එබැවින් ඔබ කිරීමට අදහස් කරන මෙහෙයුම් මත පදනම්ව, ඔබ ඒ අනුව ක්‍රියාත්මක කිරීම් තෝරා ගත යුතුය. ඕනෑම ආකාරයක ලැයිස්තුවක් උපුටා දැක්වීම ප්‍රායෝගිකව සමානව ලාභදායී වේ. (ක කට එල්ලාවල මහතා ArrayListතාක්ෂණික වේගවත් වේ, නමුත් ඔබ ඇත්තටම කාර්ය සාධන සංවේදී දෙයක් කරන්නේ නම් මිස, ඔබ මේ ගැන කරදර නොවිය යුතු - ඔවුන් නියත නිසා.)

LinkedListමූලද්‍රව්‍ය ඇතුළු කිරීමට සහ ඉවත් කිරීමට ඔබ දැනට පවතින අනුකාරක නැවත භාවිතා කරන විට පැන නගින ප්‍රධාන වාසි පැන නගී. ලැයිස්තුව දේශීයව පමණක් වෙනස් කිරීමෙන් මෙම මෙහෙයුම් O (1) හි කළ හැකිය. රාශියද ලැයිස්තුව තුළ, අරාව අවශ්යතා ඉතිරි කිරීමට ගෙන (එනම් පිටපත්). අනෙක් පැත්තෙන්, නරකම අවස්ථාව සඳහා O (n) ( n / 2 පියවර) LinkedListහි ඇති සම්බන්ධතා අනුගමනය කරමින් මාධ්‍යයක් සෙවීම, අපේක්ෂිත ස්ථානයක ගණිතමය වශයෙන් ගණනය කර O (1) වෙත ප්‍රවේශ විය හැකිය .ArrayList

LinkedListලැයිස්තුවේ ප්‍රධානියාගෙන් ඔබ එකතු කරන විට හෝ ඉවත් කරන විට භාවිතා වන තවත් වාසියක් වන්නේ , එම මෙහෙයුම් O (1) වන අතර ඒවා O (n) වන අතර ArrayList. හිසෙන් එකතු කිරීම සහ ඉවත් කිරීම සඳහා ArrayDequeහොඳ විකල්පයක් විය හැකි බව සලකන්න LinkedList, නමුත් එය a නොවේ List.

එසේම, ඔබට විශාල ලැයිස්තු තිබේ නම්, මතක භාවිතය ද වෙනස් බව මතක තබා ගන්න. LinkedListඊලඟ සහ පෙර මූලද්‍රව්‍යයන් සඳහා වන දර්ශක ද ගබඩා කර ඇති බැවින් a හි සෑම මූලද්‍රව්‍යයකටම වඩා ඉහළින් ඇත. ArrayListsමේ පොදු කාර්යය නැහැ. කෙසේ වෙතත්, ArrayListsමූලද්‍රව්‍ය සැබවින්ම එකතු කර තිබේද යන්න නොසලකා ධාරිතාව සඳහා වෙන් කර ඇති තරම් මතකය ගන්න.

A හි පෙරනිමි ආරම්භක ධාරිතාව ArrayListඉතා කුඩාය (10 ජාවා 1.4 - 1.8 සිට). නමුත් යටින් ක්‍රියාත්මක කිරීම අරාව බැවින්, ඔබ බොහෝ අංග එකතු කරන්නේ නම් අරාව ප්‍රමාණය වෙනස් කළ යුතුය. ඔබ බොහෝ මූලද්‍රව්‍ය එකතු කිරීමට යන බව දැනගත් විට ප්‍රතිප්‍රමාණනය කිරීමේ අධික පිරිවැය වළක්වා ගැනීම ArrayListසඳහා, ඉහළ ආරම්භක ධාරිතාවක් සහිතව එය සාදන්න.

මේ දක්වා, මෙම එක් එක් ලැයිස්තුවේ මතක අඩිපාරට කිසිවෙකු ආමන්ත්‍රණය කර ඇති බවක් නොපෙනේ LinkedListArrayList නොපෙනේ. ඒකට වඩා “ගොඩක් වැඩිය” ලැයිස්තු දෙකම N ශුන්‍ය යොමු කිරීම් සඳහා කොපමණ ප්‍රමාණයක් ගත යුතුද යන්න නිරූපණය කිරීම සඳහා මම සංඛ්‍යා බිඳ දැමීමක් කළෙමි.

යොමු කිරීම් ඒවායේ සාපේක්ෂ පද්ධතිවල බිටු 32 හෝ 64 (ශුන්‍ය වූ විට පවා) බැවින්, මම 32 සහ 64 බිට් සඳහා දත්ත කට්ටල 4 ක් ඇතුළත් කර ඇත්තෙමි. LinkedLists හා ArrayLists.

සටහන:ArrayList රේඛා සඳහා පෙන්වා ඇති ප්‍රමාණයන් කැපූ ලැයිස්තු සඳහා වේ - ප්‍රායෝගිකව, a හි පසුබිම් අරාවේ ධාරිතාව ArrayListසාමාන්‍යයෙන් එහි වර්තමාන මූලද්‍රව්‍ය ගණනට වඩා විශාල වේ.

සටහන 2: (ස්තූතියි BeeOnRope) සම්පීඩිත ඕප්ස් දැන් JDK6 මැද සිට ඉහළට පෙරනිමියෙන් ඇති බැවින්, බිට් 64 යන්ත්‍ර සඳහා පහත අගයන් මූලික වශයෙන් ඒවායේ 32-බිට් සගයන්ට ගැලපේ, ඇත්ත වශයෙන්ම ඔබ එය විශේෂයෙන් අක්‍රිය නොකරන්නේ නම්.

ප්‍රති result ලය පැහැදිලිවම පෙන්නුම් කරන්නේ LinkedListඑය ArrayListඉතා ඉහළ මූලද්‍රව්‍ය ගණනක් සමඟ වඩා වැඩි බවයි . මතකය සාධකයක් නම්, ඉවත් වන්න LinkedLists.

මා භාවිතා කළ සූත්‍ර අනුගමනය කරන්නේ, මම කිසියම් වැරැද්දක් කර ඇත්දැයි මට දන්වන්න, මම එය නිවැරදි කරමි. 'b' යනු බිට් 32 හෝ 64 සඳහා 4 හෝ 8 වන අතර 'n' යනු මූලද්‍රව්‍ය ගණන වේ. මොඩ්ස් සඳහා හේතුව සැලකිල්ලට ගන්න, ජාවාහි ඇති සියලුම වස්තූන් සියල්ලම භාවිතා කළත් නැතත් නොසලකා බයිට් 8 ක ඉඩ ප්‍රමාණයක් ගනී.

අරා ලැයිස්තුව:

ArrayList object header + size integer + modCount integer + array reference + (array oject header + b * n) + MOD(array oject, 8) + MOD(ArrayList object, 8) == 8 + 4 + 4 + b + (12 + b * n) + MOD(12 + b * n, 8) + MOD(8 + 4 + 4 + b + (12 + b * n) + MOD(12 + b * n, 8), 8)

සම්බන්ධිත ලැයිස්තුව:

LinkedList object header + size integer + modCount integer + reference to header + reference to footer + (node object overhead + reference to previous element + reference to next element + reference to element) * n) + MOD(node object, 8) * n + MOD(LinkedList object, 8) == 8 + 4 + 4 + 2 * b + (8 + 3 * b) * n + MOD(8 + 3 * b, 8) * n + MOD(8 + 4 + 4 + 2 * b + (8 + 3 * b) * n + MOD(8 + 3 * b, 8) * n, 8)

ArrayListඔබට අවශ්‍ය දේ. LinkedListසෑම විටම පාහේ (කාර්ය සාධන) දෝෂයකි.

LinkedListඋරා බොන්නේ ඇයි :

• එය කුඩා මතක වස්තු ගොඩක් භාවිතා කරයි, එම නිසා ක්‍රියාවලිය පුරා ක්‍රියාකාරිත්වයට බලපෑම් කරයි.
• කුඩා වස්තූන් ගොඩක් හැඹිලි-ප්‍රදේශයට නරක ය.
• ඕනෑම සුචිගත කළ මෙහෙයුමකට සංචලනය අවශ්‍ය වේ, එනම් O (n) කාර්ය සාධනය ඇත. ප්‍රභව කේතයේ මෙය පැහැදිලිව නොපෙන්වන අතර O (n) ඇල්ගොරිතම ArrayListභාවිතා කිරීමට වඩා මන්දගාමී වේ .
• හොඳ කාර්ය සාධනයක් ලබා ගැනීම උපක්‍රමශීලී ය.
• බිග්-ඕ කාර්ය සාධනය සමාන වූවත් ArrayList, එය කෙසේ හෝ සැලකිය යුතු ලෙස මන්දගාමී වනු ඇත.
• LinkedListමූලාශ්‍රයෙන් බැලීමට එය ජරා වේ, මන්ද එය බොහෝ විට වැරදි තේරීමක් විය හැකිය.

දශකයක පමණ කාලයක් තිස්සේ ඉතා විශාල පරිමාණයේ SOA වෙබ් සේවාවන්හි මෙහෙයුම් කාර්ය සාධන ඉංජිනේරු කටයුතු කරන අයෙකු ලෙස, මම අරා ලැයිස්තු වලට වඩා LinkedList හි හැසිරීමට කැමැත්තෙමි. LinkedList හි ස්ථායී ප්‍රති put ලය වඩාත් නරක වන අතර එම නිසා වැඩි දෘඩාංග මිලදී ගැනීමට හේතු විය හැක - පීඩනය යටතේ ඇති ArrayList හි හැසිරීම පොකුරු වල යෙදුම් වලට ඔවුන්ගේ අරා ආසන්න සමමුහුර්තව ව්‍යාප්ත කිරීමට හේතු විය හැකි අතර විශාල අරා ප්‍රමාණ සඳහා ප්‍රතිචාර දැක්වීමේ lack නතාවයට හේතු විය හැක. යෙදුම තුළ සහ ඇනහිටීමක්, පීඩනය යටතේ සිටියදී, එය විනාශකාරී හැසිරීමකි.

ඒ හා සමානව, ඔබට සුපුරුදු ප්‍රතිදාන කුලී එකතු කරන්නාගෙන් යෙදුමකින් වඩා හොඳ ප්‍රතිදානයක් ලබා ගත හැකිය, නමුත් ඔබ 10GB ගොඩවල් සහිත ජාවා යෙදුම් ලබා ගත් පසු පූර්ණ GC තුළ තත්පර 25 ක් සඳහා යෙදුම අගුළු දැමිය හැකිය, එමඟින් SOA යෙදුම්වල කල් ඉකුත් වීමට හා අසමත් වීමට හේතු වේ. ඔබේ ශ්‍රී.ලං.ප්‍ර. සීඑම්එස් එකතු කරන්නා වැඩි සම්පත් ප්‍රමාණයක් ලබාගෙන එකම අමු ප්‍රති put ල අත්කර නොගත්තද, එය වඩා හොඳ තේරීමක් වන්නේ එයට වඩා පුරෝකථනය කළ හැකි හා කුඩා ප්‍රමාදයක් ඇති බැවිනි.

ArrayList යනු කාර්ය සාධනය සඳහා වඩා හොඳ තේරීමක් නම් ඔබ කාර්ය සාධනයෙන් අදහස් කරන්නේ සියල්ල ප්‍රති put ල වන අතර ඔබට ප්‍රමාදය නොසලකා හැරිය හැකිය. මගේ රැකියාවේ මගේ අත්දැකීම් අනුව මට නරකම ප්‍රමාදය නොසලකා හැරිය නොහැකිය.

Algorithm           ArrayList   LinkedList
seek front            O(1)         O(1)
seek back             O(1)         O(1)
seek to index         O(1)         O(N)
insert at front       O(N)         O(1)
insert at back        O(1)         O(1)
insert after an item  O(N)         O(1)

ඇල්ගොරිතම: බිග්-ඕ අංකනය

අරා ලැයිස්තු ලිවීමට-වරක් කියවීමට-බොහෝ හෝ උපග්‍රන්ථ සඳහා හොඳ ය, නමුත් ඉදිරිපස හෝ මැද සිට එකතු කිරීමට / ඉවත් කිරීමට නරක ය.

ඔව්, මම දන්නවා, මෙය පුරාණ ප්‍රශ්නයක්, නමුත් මම මගේ ශත දෙක තුළට විසි කරමි:

LinkedList සෑම විටම පාහේ වැරදි තේරීම, කාර්ය සාධනය අනුව ය. සබැඳි ලැයිස්තුවක් ඉල්ලා සිටින ඉතා නිශ්චිත ඇල්ගොරිතම කිහිපයක් ඇත, නමුත් ඒවා ඉතා දුර්ලභ වන අතර ඇල්ගොරිතම සාමාන්‍යයෙන් විශේෂයෙන් රඳා පවතින්නේ ඔබ එහි සැරිසැරූ පසු ලැයිස්තුවේ මැද ඇති මූලද්‍රව්‍ය සාපේක්ෂව ඉක්මණින් ඇතුළු කිරීමට සහ මකා දැමීමට ලින්ක්ඩ්ලිස්ට් සතු හැකියාව මත ය. ListIterator සමඟ.

LinkedList විසින් ArrayList අභිබවා යන එක් පොදු භාවිත අවස්ථාවක් තිබේ: පෝලිමේ. කෙසේ වෙතත්, ඔබේ ඉලක්කය කාර්ය සාධනය නම්, LinkedList වෙනුවට ඔබ ArrayBlockingQueue භාවිතා කිරීම ගැනද සලකා බැලිය යුතුය (ඔබට නියමිත වේලාවට පෙර ඔබේ පෝලිම් ප්‍රමාණයට ඉහළ සීමාවක් තීරණය කළ හැකි නම් සහ සියලු මතකය ඉදිරියෙන් තැබිය හැකි නම්), හෝ මෙම චක්‍රලේඛ අරා ලැයිස්තු ක්‍රියාත්මක කිරීම . (ඔව්, එය 2001 සිට ය, එබැවින් ඔබට එය සාමාන්‍යකරණය කිරීමට අවශ්‍ය වනු ඇත, නමුත් මෑත ජේවීඑම් හි ලිපියේ සඳහන් කර ඇති දේ සමඟ සැසඳිය හැකි කාර්ය සාධන අනුපාත මට ලැබුණි)

එය කාර්යක්ෂමතා ප්‍රශ්නයකි. LinkedListමූලද්‍රව්‍ය එකතු කිරීම සහ මකා දැමීම සඳහා වේගවත් වන නමුත් නිශ්චිත මූලද්‍රව්‍යයකට ප්‍රවේශ වීමට ප්‍රමාද වේ. ArrayListනිශ්චිත මූලද්‍රව්‍යයකට ප්‍රවේශ වීම සඳහා වේගවත් වන නමුත් එක් කෙළවරකට එකතු කිරීම මන්දගාමී විය හැකි අතර විශේෂයෙන් මධ්යයේ මකා දැමීමට මන්දගාමී වේ.

අරා එදිරිව අරේලිස්ට් එදිරිව සබැඳි ලැයිස්තුව එදිරිව දෛශිකය සම්බන්ධිත ලැයිස්තුවට වඩා ගැඹුරට යයි .

නිවැරදි හෝ වැරදි: කරුණාකර දේශීයව පරීක්ෂණය සිදු කර ඔබම තීරණය කරන්න!

සංස්කරණය කරන්න / ඉවත් කරන්න වේගවත් වේ LinkedListවඩා ArrayList.

ArrayList, පිටුබලය Array , ප්‍රමාණය මෙන් දෙගුණයක් විය යුතුය, විශාල පරිමාව යෙදීමේදී වඩාත් නරක ය.

පහත දැක්වෙන්නේ එක් එක් මෙහෙයුම සඳහා ඒකක පරීක්ෂණ ප්‍රති result ලයයි.

Operation                       ArrayList                      LinkedList  

AddAll   (Insert)               101,16719                      2623,29291 

Add      (Insert-Sequentially)  152,46840                      966,62216

Add      (insert-randomly)      36527                          29193

remove   (Delete)               20,56,9095                     20,45,4904

contains (Search)               186,15,704                     189,64,981

මෙන්න කේතය:

import org.junit.Assert;
import org.junit.Test;

import java.util.*;

public class ArrayListVsLinkedList {
    private static final int MAX = 500000;
    String[] strings = maxArray();

    ////////////// ADD ALL ////////////////////////////////////////
    @Test
    public void arrayListAddAll() {
        Watch watch = new Watch();
        List<String> stringList = Arrays.asList(strings);
        List<String> arrayList = new ArrayList<String>(MAX);

        watch.start();
        arrayList.addAll(stringList);
        watch.totalTime("Array List addAll() = ");//101,16719 Nanoseconds
    }

    @Test
    public void linkedListAddAll() throws Exception {
        Watch watch = new Watch();
        List<String> stringList = Arrays.asList(strings);

        watch.start();
        List<String> linkedList = new LinkedList<String>();
        linkedList.addAll(stringList);
        watch.totalTime("Linked List addAll() = ");  //2623,29291 Nanoseconds
    }

    //Note: ArrayList is 26 time faster here than LinkedList for addAll()

    ///////////////// INSERT /////////////////////////////////////////////
    @Test
    public void arrayListAdd() {
        Watch watch = new Watch();
        List<String> arrayList = new ArrayList<String>(MAX);

        watch.start();
        for (String string : strings)
            arrayList.add(string);
        watch.totalTime("Array List add() = ");//152,46840 Nanoseconds
    }

    @Test
    public void linkedListAdd() {
        Watch watch = new Watch();

        List<String> linkedList = new LinkedList<String>();
        watch.start();
        for (String string : strings)
            linkedList.add(string);
        watch.totalTime("Linked List add() = ");  //966,62216 Nanoseconds
    }

    //Note: ArrayList is 9 times faster than LinkedList for add sequentially

    /////////////////// INSERT IN BETWEEN ///////////////////////////////////////

    @Test
    public void arrayListInsertOne() {
        Watch watch = new Watch();
        List<String> stringList = Arrays.asList(strings);
        List<String> arrayList = new ArrayList<String>(MAX + MAX / 10);
        arrayList.addAll(stringList);

        String insertString0 = getString(true, MAX / 2 + 10);
        String insertString1 = getString(true, MAX / 2 + 20);
        String insertString2 = getString(true, MAX / 2 + 30);
        String insertString3 = getString(true, MAX / 2 + 40);

        watch.start();

        arrayList.add(insertString0);
        arrayList.add(insertString1);
        arrayList.add(insertString2);
        arrayList.add(insertString3);

        watch.totalTime("Array List add() = ");//36527
    }

    @Test
    public void linkedListInsertOne() {
        Watch watch = new Watch();
        List<String> stringList = Arrays.asList(strings);
        List<String> linkedList = new LinkedList<String>();
        linkedList.addAll(stringList);

        String insertString0 = getString(true, MAX / 2 + 10);
        String insertString1 = getString(true, MAX / 2 + 20);
        String insertString2 = getString(true, MAX / 2 + 30);
        String insertString3 = getString(true, MAX / 2 + 40);

        watch.start();

        linkedList.add(insertString0);
        linkedList.add(insertString1);
        linkedList.add(insertString2);
        linkedList.add(insertString3);

        watch.totalTime("Linked List add = ");//29193
    }


    //Note: LinkedList is 3000 nanosecond faster than ArrayList for insert randomly.

    ////////////////// DELETE //////////////////////////////////////////////////////
    @Test
    public void arrayListRemove() throws Exception {
        Watch watch = new Watch();
        List<String> stringList = Arrays.asList(strings);
        List<String> arrayList = new ArrayList<String>(MAX);

        arrayList.addAll(stringList);
        String searchString0 = getString(true, MAX / 2 + 10);
        String searchString1 = getString(true, MAX / 2 + 20);

        watch.start();
        arrayList.remove(searchString0);
        arrayList.remove(searchString1);
        watch.totalTime("Array List remove() = ");//20,56,9095 Nanoseconds
    }

    @Test
    public void linkedListRemove() throws Exception {
        Watch watch = new Watch();
        List<String> linkedList = new LinkedList<String>();
        linkedList.addAll(Arrays.asList(strings));

        String searchString0 = getString(true, MAX / 2 + 10);
        String searchString1 = getString(true, MAX / 2 + 20);

        watch.start();
        linkedList.remove(searchString0);
        linkedList.remove(searchString1);
        watch.totalTime("Linked List remove = ");//20,45,4904 Nanoseconds
    }

    //Note: LinkedList is 10 millisecond faster than ArrayList while removing item.

    ///////////////////// SEARCH ///////////////////////////////////////////
    @Test
    public void arrayListSearch() throws Exception {
        Watch watch = new Watch();
        List<String> stringList = Arrays.asList(strings);
        List<String> arrayList = new ArrayList<String>(MAX);

        arrayList.addAll(stringList);
        String searchString0 = getString(true, MAX / 2 + 10);
        String searchString1 = getString(true, MAX / 2 + 20);

        watch.start();
        arrayList.contains(searchString0);
        arrayList.contains(searchString1);
        watch.totalTime("Array List addAll() time = ");//186,15,704
    }

    @Test
    public void linkedListSearch() throws Exception {
        Watch watch = new Watch();
        List<String> linkedList = new LinkedList<String>();
        linkedList.addAll(Arrays.asList(strings));

        String searchString0 = getString(true, MAX / 2 + 10);
        String searchString1 = getString(true, MAX / 2 + 20);

        watch.start();
        linkedList.contains(searchString0);
        linkedList.contains(searchString1);
        watch.totalTime("Linked List addAll() time = ");//189,64,981
    }

    //Note: Linked List is 500 Milliseconds faster than ArrayList

    class Watch {
        private long startTime;
        private long endTime;

        public void start() {
            startTime = System.nanoTime();
        }

        private void stop() {
            endTime = System.nanoTime();
        }

        public void totalTime(String s) {
            stop();
            System.out.println(s + (endTime - startTime));
        }
    }


    private String[] maxArray() {
        String[] strings = new String[MAX];
        Boolean result = Boolean.TRUE;
        for (int i = 0; i < MAX; i++) {
            strings[i] = getString(result, i);
            result = !result;
        }
        return strings;
    }

    private String getString(Boolean result, int i) {
        return String.valueOf(result) + i + String.valueOf(!result);
    }
}

LinkedList හි කර්තෘ ජෝෂුවා බ්ලොච්:

කවුරුහරි ඇත්ත වශයෙන්ම LinkedList භාවිතා කරනවාද? මම එය ලිවූ අතර මම එය කිසි විටෙකත් භාවිතා නොකරමි.

සබැඳිය: https://twitter.com/joshbloch/status/583813919019573248

අනෙක් පිළිතුරු තරම් තොරතුරු නොදැක්වීම ගැන මට කණගාටුයි, නමුත් එය වඩාත් රසවත් හා ස්වයං පැහැදිලි කිරීමක් වනු ඇතැයි මම සිතුවෙමි.

ArrayList අත්‍යවශ්‍යයෙන්ම අරාවකි. LinkedListද්විත්ව සම්බන්ධිත ලැයිස්තුවක් ලෙස ක්‍රියාත්මක වේ.

මෙම getලස්සන පැහැදිලි වේ. O (1) සඳහා ArrayList, මන්දයත් ArrayListදර්ශකය භාවිතා කර අහඹු ලෙස ප්‍රවේශ වීමට ඉඩ දෙන්න. O (n) සඳහා LinkedList, එයට මුලින් දර්ශකය සොයා ගත යුතු බැවිනි. සටහන: addසහ විවිධ අනුවාදයන් ඇතremove .

LinkedListඑකතු කිරීම සහ ඉවත් කිරීම වේගවත් වේ, නමුත් ලබා ගැනීම මන්දගාමී වේ. කෙටියෙන් කිවහොත් LinkedList:

1. මූලද්‍රව්‍යයට අහඹු ලෙස ප්‍රවේශ වීමේ විශාල සංඛ්‍යාවක් නොමැත
2. එකතු කිරීමේ / ඉවත් කිරීමේ මෙහෙයුම් විශාල සංඛ්‍යාවක් ඇත

=== අරා ලැයිස්තු ===

• එකතු කරන්න (ඊ ඊ)
  • ArrayList අවසානයේ එකතු කරන්න
  • මතක ප්‍රමාණය වෙනස් කිරීමේ පිරිවැය අවශ්‍ය වේ.
  • O (n) නරකම, O (1) ක්‍රමක්ෂය
• එකතු කරන්න (int දර්ශකය, E මූලද්‍රව්‍යය)
  • නිශ්චිත දර්ශක ස්ථානයකට එක් කරන්න
  • මාරුවීමේ සහ හැකි මතක ප්‍රමාණය වෙනස් කිරීමේ පිරිවැය අවශ්‍ය වේ
  • මත)
• ඉවත් කරන්න (int දර්ශකය)
  • නිශ්චිත අංගයක් ඉවත් කරන්න
  • මාරුවීමේ සහ හැකි මතක ප්‍රමාණය වෙනස් කිරීමේ පිරිවැය අවශ්‍ය වේ
  • මත)
• ඉවත් කරන්න (වස්තුව o)
  • මෙම ලැයිස්තුවෙන් නිශ්චිත මූලද්‍රව්‍යයේ පළමු සිදුවීම ඉවත් කරන්න
  • පළමුවෙන්ම මූලද්‍රව්‍යය සෙවිය යුතු අතර, පසුව මාරු කළ හැකි සහ මතක ප්‍රමාණය වෙනස් කිරීමේ පිරිවැය
  • මත)

=== LinkedList ===

• එකතු කරන්න (ඊ ඊ)

  • ලැයිස්තුවේ අවසානයට එක් කරන්න
  • ඕ (1)

• එකතු කරන්න (int දර්ශකය, E මූලද්‍රව්‍යය)

  • නිශ්චිත ස්ථානයේ ඇතුල් කරන්න
  • පළමුව ස්ථානය සොයා ගැනීමට අවශ්‍යයි
  • මත)
• ඉවත් කරන්න ()
  • ලැයිස්තුවේ පළමු අංගය ඉවත් කරන්න
  • ඕ (1)
• ඉවත් කරන්න (int දර්ශකය)
  • නිශ්චිත දර්ශකය සමඟ මූලද්‍රව්‍යය ඉවත් කරන්න
  • මුලින්ම මූලද්‍රව්‍යය සොයා ගැනීමට අවශ්‍යයි
  • මත)
• ඉවත් කරන්න (වස්තුව o)
  • නිශ්චිත මූලද්රව්යයේ පළමු සිදුවීම ඉවත් කරන්න
  • මුලින්ම මූලද්‍රව්‍යය සොයා ගැනීමට අවශ්‍යයි
  • මත)

මෙන්න programcreek.com හි රූපයක් ( addසහ removeපළමු වර්ගය, එනම්, ලැයිස්තුව අවසානයේ මූලද්‍රව්‍යයක් එකතු කර ලැයිස්තුවේ නිශ්චිත ස්ථානයේ ඇති මූලද්‍රව්‍යය ඉවත් කරන්න.):

ArrayListඅහඹු ලෙස ප්‍රවේශ විය හැකි අතර, LinkedListමූලද්‍රව්‍ය පුළුල් කිරීමට සහ ඉවත් කිරීමට ඇත්තෙන්ම ලාභදායී වේ. බොහෝ අවස්ථාවලදී, ArrayListහොඳයි.

ඔබ විශාල ලැයිස්තු නිර්මාණය කර බාධකයක් මනින්නේ නැත්නම්, ඔබට කිසි විටෙකත් වෙනස ගැන කරදර විය යුතු නැත.

නවීන පරිගණක ගෘහ නිර්මාණ ශිල්පය හේතුවෙන් ටීඑල්; ඩීආර් , ArrayListහැකි ඕනෑම භාවිත අවස්ථාවකට සැලකිය යුතු ලෙස කාර්යක්ෂම වනු ඇත - එබැවින් LinkedListඉතා සුවිශේෂී හා ආන්තික අවස්ථා හැරෙන්නට එය වළක්වා ගත යුතුය.

න්‍යායට අනුව, LinkedList සඳහා O (1) ඇත add(E element)

ලැයිස්තුවක් මැද මූලද්‍රව්‍යයක් එකතු කිරීම ඉතා කාර්යක්ෂම විය යුතුය.

LinkedList යනු හැඹිලි සතුරු දත්ත ව්‍යුහයක් බැවින් පුහුණුව බෙහෙවින් වෙනස් ය . POV කාර්ය සාධනයෙන් - හැඹිලි-හිතකාමීත්වයටLinkedList වඩා හොඳින් ක්‍රියා කළ හැකි අවස්ථා ඉතා අල්පය ArrayList .

අහඹු ස්ථානවල මූලද්‍රව්‍ය ඇතුළත් කිරීමේ මිණුම් සලකුණු පරීක්ෂණයේ ප්‍රති results ල මෙන්න. ඔබට පෙනෙන පරිදි - අරාව ලැයිස්තුව වඩාත් කාර්යක්ෂම නම්, න්‍යායිකව ලැයිස්තුවේ මැදට එක් එක් ඇතුළත් කිරීම අරාවෙහි පසුකාලීන මූලද්‍රව්‍ය n ගෙනයාමට අවශ්‍ය වුවද (පහළ අගයන් වඩා හොඳය):

පසු පරම්පරාවේ දෘඩාංගයක වැඩ කිරීම (විශාල, වඩා කාර්යක්ෂම හැඹිලි) - ප්‍රති results ල ඊටත් වඩා තීරණාත්මක ය:

එකම කාර්යය ඉටු කිරීම සඳහා LinkedList වැඩි කාලයක් ගතවේ. මූලාශ්රය ප්‍රභව කේතය

මේ සඳහා ප්‍රධාන හේතු දෙකක් තිබේ:

1. ප්රධාන වශයෙන් - LinkedListමතකය අහඹු ලෙස මතකය පුරා විසිරී ඇති බව. RAM ("සසම්භාවී ප්‍රවේශ මතකය") සැබවින්ම අහඹු නොවන අතර මතක කොටස් වාරණය කිරීමට අවශ්‍ය වේ. මෙම මෙහෙයුමට කාලය ගත වන අතර, එවැනි වර්‍ගයන් නිතර සිදුවන විට - හැඹිලියේ මතක පිටු නිතරම ප්‍රතිස්ථාපනය කළ යුතුය -> හැඹිලිය මග හැරේ -> හැඹිලිය කාර්යක්ෂම නොවේ. ArrayListමූලද්‍රව්‍ය අඛණ්ඩ මතකය මත ගබඩා කර ඇත - එය නූතන CPU ගෘහ නිර්මාණ ශිල්පය ප්‍රශස්තිකරණය කරන්නේ හරියටම ය.

2. LinkedListපසුපසට / ඉදිරි දර්ශකයන් රඳවා තබා ගැනීමට ද්විතීයික අවශ්‍ය වේ, එයින් අදහස් වන්නේ ගබඩා කළ අගයකට සාපේක්ෂව මතක පරිභෝජනය මෙන් 3 ගුණයක් බවයි ArrayList.

DynamicIntArray , btw , යනු අභිරුචි අරා ලැයිස්තු ක්‍රියාත්මක කිරීමේ රඳවා ගැනීමකිInt (ප්‍රාථමික වර්ගය) මිස වස්තු නොවේ - එබැවින් සියලු දත්ත සැබවින්ම යාබදව ගබඩා කර ඇත - එබැවින් ඊටත් වඩා කාර්යක්ෂම වේ.

මතක තබා ගත යුතු ප්‍රධාන අංගයක් වන්නේ මතක බ්ලොක් එකක් ලබා ගැනීමේ පිරිවැය තනි මතක සෛලයකට ප්‍රවේශ වීමේ පිරිවැයට වඩා වැදගත් බවයි. විවිධ මතක කොටස් වලින් මෙම දත්ත කියවීමට වඩා 1MB අනුක්‍රමික මතකය x400 ගුණයකින් වේගවත් වන්නේ එබැවිනි.

Latency Comparison Numbers (~2012)
----------------------------------
L1 cache reference                           0.5 ns
Branch mispredict                            5   ns
L2 cache reference                           7   ns                      14x L1 cache
Mutex lock/unlock                           25   ns
Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy             3,000   ns        3 us
Send 1K bytes over 1 Gbps network       10,000   ns       10 us
Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD
Read 1 MB sequentially from memory     250,000   ns      250 us
Round trip within same datacenter      500,000   ns      500 us
Read 1 MB sequentially from SSD*     1,000,000   ns    1,000 us    1 ms  ~1GB/sec SSD, 4X memory
Disk seek                           10,000,000   ns   10,000 us   10 ms  20x datacenter roundtrip
Read 1 MB sequentially from disk    20,000,000   ns   20,000 us   20 ms  80x memory, 20X SSD
Send packet CA->Netherlands->CA    150,000,000   ns  150,000 us  150 ms

මූලාශ්රය: සෑම ක්‍රමලේඛකයෙකුම දැනගත යුතු ගුප්ත සංඛ්‍යා

කාරණය වඩාත් පැහැදිලි කිරීම සඳහා, කරුණාකර ලැයිස්තුවේ ආරම්භයට මූලද්‍රව්‍ය එකතු කිරීමේ මිණුම් ලකුණ පරීක්ෂා කරන්න. මෙය න්‍යායාත්මකව LinkedListසැබවින්ම බැබළවිය ArrayListයුතු අතර දුර්වල හෝ ඊටත් වඩා නරක ප්‍රති results ල ඉදිරිපත් කළ යුතු භාවිත අවස්ථාවකි:

සටහන: මෙය C ++ Std lib හි මිණුම් ලකුණකි, නමුත් මගේ පෙර අත්දැකීම් C ++ සහ Java ප්‍රති results ල ඉතා සමාන ය. ප්රභව කේතය

අනුක්‍රමික මතක තොගයක් පිටපත් කිරීම නූතන CPU විසින් ප්‍රශස්තිකරණය කරන ලද මෙහෙයුමකි - න්‍යාය වෙනස් කිරීම සහ ඇත්ත වශයෙන්ම නැවත වරක් ArrayList/ Vectorවඩා කාර්යක්ෂම කිරීම

බැර: මෙහි පළ කර ඇති සියලුම මිණුම් සලකුණු නිර්මාණය කර ඇත්තේ කෙජල් හෙඩ්ස්ට්‍රෝම් විසිනි. ඊටත් වඩා දත්ත ඔහුගේ බ්ලොග් අඩවියෙන් සොයාගත හැකිය

ඔබගේ කේතය තිබේ නම් add(0)සහ remove(0), එය භාවිතා LinkedListහා එය ලස්සන තියෙන්නේ addFirst()හා removeFirst()ක්රම. එසේ නොමැතිනම් භාවිතා කරන්න ArrayList.

හා එක් එක් පාඨමාලාව, පේර ගේ ImmutableList ඔබේ හොඳම යාළුවා.

මෙය පැරණි තනතුරක් බව මම දනිමි, නමුත් කිසිවෙකු එය LinkedListක්‍රියාත්මක කරන බව සඳහන් කර ඇතැයි මට විශ්වාස කළ නොහැකිය Deque. Deque(සහ Queue) හි ඇති ක්‍රම දෙස බලන්න ; ඔබට සාධාරණ සැසඳීමක් අවශ්‍ය නම්, ඒවාට LinkedListඑරෙහිව ධාවනය කිරීමට උත්සාහ ArrayDequeකර විශේෂාංග සඳහා විශේෂාංග සංසන්දනයක් කරන්න.

මෙන්න දෙකම බිග්-O අංකනය වේ ArrayListහා LinkedListද සහ CopyOnWrite-ArrayList:

අරා ලැයිස්තු

get                 O(1)
add                 O(1)
contains            O(n)
next                O(1)
remove              O(n)
iterator.remove     O(n)

සම්බන්ධිත ලැයිස්තුව

get                 O(n)
add                 O(1)
contains            O(n)
next                O(1)
remove              O(1)
iterator.remove     O(1)

CopyOnWrite-ArrayList

get                 O(1)
add                 O(n)
contains            O(n)
next                O(1)
remove              O(n)
iterator.remove     O(n)

මේවා මත පදනම්ව ඔබ තෝරා ගත යුතු දේ තීරණය කළ යුතුය. :)

පරාමිති වලට පහළින් ඇති LinkedList සහ ArrayList wrt සංසන්දනය කරමු:

1. ක්‍රියාත්මක කිරීම

අරා ලැයිස්තු යනු ලැයිස්තු අතුරුමුහුණතේ ප්‍රතිනිර්මාණය කළ හැකි අරාව ක්‍රියාත්මක කිරීමයි

LinkedList යනු ලැයිස්තු අතුරුමුහුණතේ ද්විත්ව සම්බන්ධිත ලැයිස්තු ක්‍රියාත්මක කිරීමයි.

2. කාර්ය සාධනය

• ලබා ගන්න (int දර්ශකය) හෝ සෙවුම් ක්‍රියාකාරිත්වය

  අරා ලැයිස්තු get (int index) ක්‍රියාකාරිත්වය නියත වේලාවක එනම් O (1) අතර ක්‍රියාත්මක වේ

  LinkedList get (int index) මෙහෙයුම් ධාවන කාලය O (n) වේ.

  ArrayList LinkedList ට වඩා වේගවත් වීමට හේතුව, ArrayList එහි මූලද්‍රව්‍ය සඳහා දර්ශක පාදක පද්ධතියක් භාවිතා කිරීම නිසා එය අභ්‍යන්තරව අරාව දත්ත ව්‍යුහයක් භාවිතා කරයි, අනෙක් අතට,

  නිශ්චිත මූලද්‍රව්‍ය දර්ශකයේ ඇති නෝඩය නැවත ලබා ගැනීම සඳහා ආරම්භයේ හෝ අවසානය සිට ( කවරක් ආසන්නයේද) පුනරාවර්තනය වන බැවින් එහි මූලද්‍රව්‍ය සඳහා දර්ශක පාදක ප්‍රවේශය LinkedList සපයන්නේ නැත.

• ඇතුළු කරන්න () හෝ එකතු කරන්න (වස්තුව) මෙහෙයුම

  ArrayList හා සසඳන විට LinkedList හි ඇතුළත් කිරීම් සාමාන්‍යයෙන් වේගවත්ය. LinkedList හි එකතු කිරීම හෝ ඇතුළත් කිරීම O (1) මෙහෙයුම වේ.

  සිටියදී ArrayList , අරාව පූර්ණ එනම් නරකම නම්, එහි අරාව, ගැලපීම් සහ ArrayList සාමාන්ය (n) එකතු මෙහෙයුම් ධාවන වන පරිදි නව අරාව, මූලද්රව්යවල පිටපත් වැඩිපුර වියදම්, වෙනත් ආකාරයකින් එය සාමාන්ය (1) වේ .

• ඉවත් කිරීමේ (int) මෙහෙයුම

  LinkedList හි ඉවත් කිරීම සාමාන්‍යයෙන් ArrayList එනම් O (n) ට සමාන වේ.

  දී LinkedList , කුරුලෑ ඉවත් ක්රම දෙකක් ඇත. එකක් පරාමිති නොමැතිව ඉවත් කිරීම () යනු ලැයිස්තුවේ හිස ඉවත් කර නියත වේලාවක O (1) ක්‍රියාත්මක වේ. LinkedList හි ඇති අධි බර පැටවීමේ ඉවත් කිරීමේ ක්‍රමය වන්නේ පරාමිතියක් ලෙස සම්මත කරන ලද වස්තුව හෝ int ඉවත් කරන (int) හෝ ඉවත් කිරීම (Object) ය. මෙම ක්‍රමය සබැඳිය ලැයිස්තුව හරහා වස්තුව සොයා ගන්නා තෙක් ගමන් කර මුල් ලැයිස්තුවෙන් එය ඉවත් කරයි. එබැවින් මෙම ක්‍රමය ක්‍රියාත්මක වන කාලය O (n) වේ.

  සිටියදී ArrayList ඉවත් (int) ක්රමය නිසා එහි ධාවන සාමාන්ය (n) වන අතර, නව යාවත්කාලීන අරාවට පැරණි අරා සිට අංග පිටපත් කිරීමයි.

3. ප්‍රතිවිකුණුම්කාරකය

අවරෝහණ ඉටිටරේටර් () භාවිතා කරමින් සම්බන්ධක ලැයිස්තුව ප්‍රතිලෝම දිශාවට නැවත කළ හැකිය

ArrayList හි අවරෝහණ ඉටරේටරය () නොමැත , එබැවින් අපි ArrayList හරහා ප්‍රතිලෝම දිශාවට නැවත යොමු කිරීම සඳහා අපේම කේතයක් ලිවිය යුතුය.

4. ආරම්භක ධාරිතාව

ඉදිකිරීම්කරු අධික ලෙස පටවා නොමැති නම්, අරේලිස්ට් ආරම්භක ධාරිතාව 10 හි හිස් ලැයිස්තුවක් නිර්මාණය කරයි

LinkedList කිසිදු ආරම්භක ධාරිතාවයකින් තොරව හිස් ලැයිස්තුව පමණක් සාදයි .

5. මතකය ඉහළින්

ඊලඟ සහ පෙර නෝඩයේ ලිපින නඩත්තු කිරීම සඳහා සබැඳි ලැයිස්තුවේ ඇති නෝඩයක් අවශ්‍ය බැවින්, අරා ලැයිස්තු සමඟ සසඳන විට, සබැඳි ලැයිස්තුවේ මතක පොදු කාර්යය වැඩිය . අතර

දී ArrayList එක් එක් දර්ශකය පමණක් සැබෑ වස්තුව (දත්ත) පවත්වයි.

මූලාශ්රය

මම සාමාන්‍යයෙන් එකක් භාවිතා කරන්නේ එම විශේෂිත ලැයිස්තුවේ මා විසින් සිදු කරනු ලබන මෙහෙයුම් වල කාල සංකීර්ණතාවයන් මත ය.

|---------------------|---------------------|--------------------|------------|
|      Operation      |     ArrayList       |     LinkedList     |   Winner   |
|---------------------|---------------------|--------------------|------------|
|     get(index)      |       O(1)          |         O(n)       | ArrayList  |
|                     |                     |  n/4 steps in avg  |            |
|---------------------|---------------------|--------------------|------------|
|      add(E)         |       O(1)          |         O(1)       | LinkedList |
|                     |---------------------|--------------------|            |
|                     | O(n) in worst case  |                    |            |
|---------------------|---------------------|--------------------|------------|
|    add(index, E)    |       O(n)          |         O(n)       | LinkedList |
|                     |     n/2 steps       |      n/4 steps     |            |
|                     |---------------------|--------------------|            |
|                     |                     |  O(1) if index = 0 |            |
|---------------------|---------------------|--------------------|------------|
|  remove(index, E)   |       O(n)          |         O(n)       | LinkedList |
|                     |---------------------|--------------------|            |
|                     |     n/2 steps       |      n/4 steps     |            |
|---------------------|---------------------|--------------------|------------|
|  Iterator.remove()  |       O(n)          |         O(1)       | LinkedList |
|  ListIterator.add() |                     |                    |            |
|---------------------|---------------------|--------------------|------------|


|--------------------------------------|-----------------------------------|
|              ArrayList               |            LinkedList             |
|--------------------------------------|-----------------------------------|
|     Allows fast read access          |   Retrieving element takes O(n)   |
|--------------------------------------|-----------------------------------|
|   Adding an element require shifting | o(1) [but traversing takes time]  |
|       all the later elements         |                                   |
|--------------------------------------|-----------------------------------|
|   To add more elements than capacity |
|    new array need to be allocated    |
|--------------------------------------|

ඉහත අනෙක් හොඳ තර්ක කිරීමට අමතරව, ඔබ සඳහන් කළ යුතු ArrayListඋපකරණ RandomAccessඅතර, අතුරු-මුහුණත් LinkedListඋපකරණ Queue.

එබැවින්, කෙසේ හෝ ඔවුන් කාර්යක්ෂමතාව සහ හැසිරීමේ වෙනස සමඟ තරමක් වෙනස් ගැටළු වලට විසඳුම් ලබා දේ (ඔවුන්ගේ ක්‍රම ලැයිස්තුව බලන්න).

එය ලැයිස්තුවේ ඔබ වැඩිපුර කරන්නේ කුමන මෙහෙයුම්ද යන්න මත රඳා පවතී.

ArrayListසුචිගත කළ අගයකට ප්‍රවේශ වීමට වේගවත් වේ. වස්තු ඇතුළු කිරීමේදී හෝ මකා දැමීමේදී එය වඩාත් නරක ය.

වැඩි විස්තර දැනගැනීම සඳහා, අරා සහ සම්බන්ධිත ලැයිස්තු අතර වෙනස ගැන කතා කරන ඕනෑම ලිපියක් කියවන්න.

අරාව ලැයිස්තුව යනු අත්‍යවශ්‍යයෙන්ම අයිතම එකතු කිරීම සඳහා ක්‍රමවේදයන් සහිත අරාවකි (ඔබ ඒ වෙනුවට සාමාන්‍ය ලැයිස්තුවක් භාවිතා කළ යුතුය). එය දර්ශකයක් හරහා ප්‍රවේශ විය හැකි අයිතම එකතුවකි (උදාහරණයක් ලෙස [0]). එය එක් අයිතමයක සිට තවත් අයිතමයක් දක්වා ප්‍රගතියක් අඟවයි.

සම්බන්ධිත ලැයිස්තුවක් මඟින් එක් අයිතමයක සිට තවත් අයිතමයක් දක්වා ප්‍රගතියක් දක්වයි (අයිතමය a -> අයිතමය b). අරාව ලැයිස්තුවක් සමඟ ඔබට එකම බලපෑමක් ලබා ගත හැකිය, නමුත් සම්බන්ධිත ලැයිස්තුවක් නියත වශයෙන්ම පවසන්නේ පෙර අයිතමය අනුගමනය කළ යුතු අයිතමය කුමක්ද යන්නයි.

ජාවා නිබන්ධන බලන්න - ලැයිස්තු ක්‍රියාත්මක කිරීම .

සම්බන්ධිත ලැයිස්තුවක වැදගත් ලක්‍ෂණයක් (මම වෙනත් පිළිතුරකින් කියවා නැති) ලැයිස්තු දෙකක සංක්ෂිප්තකරණයයි. අරාව සමඟ මෙය සම්බන්ධිත ලැයිස්තුවක් සහිත O (n) (+ සමහර නැවත වෙන් කිරීම්වල ඉහළින්) මෙය O (1) හෝ O (2) ;-)

වැදගත් : ජාවා සඳහා LinkedListමෙය සත්‍ය නොවේ! බලන්න ජාවා හි සම්බන්ධිත ලැයිස්තුව සඳහා වේගවත් කොන්ක්‍රීට් ක්‍රමයක් තිබේද?

ArrayList සහ LinkedList වලට ඔවුන්ගේම වාසි සහ අවාසි ඇත.

ඊලඟ නෝඩය දෙසට දර්ශක භාවිතා කරන LinkedList හා සසඳන විට ArrayList විසින් පරස්පර මතක ලිපිනයක් භාවිතා කරයි. එබැවින් ඔබට අරා ලැයිස්තුවේ මූලද්‍රව්‍යයක් බැලීමට අවශ්‍ය වූ විට එය සබැඳි ලැයිස්තුව සමඟ නැවත නැවත සිදු කිරීමට වඩා වේගවත් වේ.

අනෙක් අතට, සම්බන්ධක ලැයිස්තුවක් තුළට ඇතුළු කිරීම සහ මකා දැමීම වඩා පහසු වන්නේ ඔබට දර්ශක වෙනස් කළ යුතු අතර අරේලිස්ට් මඟින් ඇඟවෙන්නේ ඕනෑම ඇතුල් කිරීමක් හෝ මකාදැමීමක් සඳහා මාරුවීමේ ක්‍රියාකාරිත්වය භාවිතා කිරීමයි.

ඔබගේ යෙදුමේ නිතර නැවත ලබා ගැනීමේ මෙහෙයුම් තිබේ නම් අරා ලැයිස්තුවක් භාවිතා කරන්න. ඔබට නිතර ඇතුළත් කිරීම සහ මකා දැමීම තිබේ නම් සබැඳි ලැයිස්තුවක් භාවිතා කරන්න.

මම ප්‍රතිචාර කියවා ඇත්තෙමි, නමුත් මම සෑම විටම අරා ලැයිස්තුවක් හරහා සම්බන්ධක ලැයිස්තුවක් භාවිතා කරන එක් අවස්ථාවක් තිබේ, මට අදහස් ඇසීමට බෙදා ගැනීමට අවශ්‍යය:

ඩීබී වෙතින් ලබාගත් දත්ත ලැයිස්තුවක් ආපසු ලබා දෙන ක්‍රමවේදයක් මා සතුව ඇති සෑම අවස්ථාවකම මම නිතරම සබැඳි ලැයිස්තුවක් භාවිතා කරමි.

මගේ තර්කය වූයේ මට කොපමණ ප්‍රති results ල ලැබේදැයි හරියටම දැනගත නොහැකි නිසා, මතකය අපතේ නොයනු ඇති බවයි (අරේලිස්ට් හි ධාරිතාව සහ සත්‍ය මූලද්‍රව්‍ය ගණන අතර වෙනස සමඟ), සහ උත්සාහ කිරීමට කාලය නාස්ති නොවනු ඇත. ධාරිතාව අනුපිටපත් කරන්න.

අරා ලැයිස්තුවක් ලෙස, හැකි තරම් අරා වල අනුපිටපත් අවම කිරීම සඳහා අවම වශයෙන් ඔබ සැමවිටම ආරම්භක ධාරිතාවයෙන් ඉදිකිරීම්කරු භාවිතා කළ යුතු බව මම එකඟ වෙමි.

ArrayListහා LinkedListආම්පන්න දෙකම List interface හා ඔවුන්ගේ උපක්රම සහ ප්රතිඵල පාහේ සමාන වේ. කෙසේ වෙතත්, අවශ්‍යතාවය අනුව ඒවා එකිනෙකට වඩා හොඳ කරවන වෙනස්කම් කිහිපයක් තිබේ.

ArrayList Vs LinkedList

1) Search: ArrayListසෙවුම් මෙහෙයුමට සාපේක්ෂව සෙවුම් මෙහෙයුම ඉතා වේගවත්ය LinkedList. get(int index)දී ArrayListකාර්ය සාධනය ලබා දෙන O(1)අතර, LinkedListකාර්ය සාධනය O(n).

Reason: ArrayListලැයිස්තුවේ මූලද්‍රව්‍යයක් සෙවීම වේගවත් කරන අරා දත්ත ව්‍යුහය ව්‍යංගයෙන් භාවිතා කරන බැවින් එහි මූලද්‍රව්‍ය සඳහා දර්ශක පාදක පද්ධතිය පවත්වාගෙන යයි. අනෙක් පැත්තෙන් LinkedListද්විත්ව සම්බන්ධිත ලැයිස්තුවක් ක්‍රියාත්මක කරන අතර එමඟින් මූලද්‍රව්‍යයක් සෙවීම සඳහා සියලු මූලද්‍රව්‍ය හරහා ගමන් කළ යුතුය.

2) Deletion: LinkedListඉවත් කිරීමේ ක්‍රියාකාරිත්වය මඟින් O(1)කාර්ය සාධනය ලබා දෙන අතර ArrayListවිචල්‍ය ක්‍රියාකාරිත්වය ලබා දෙයි: O(n)නරකම අවස්ථාවක (පළමු අංගය ඉවත් කරන අතරතුර) සහ O(1)හොඳම අවස්ථාවෙහිදී (අවසාන අංගය ඉවත් කරන අතරතුර).

නිගමනය: ArrayList හා සසඳන විට LinkedList මූලද්‍රව්‍ය මකාදැමීම වේගවත් වේ.

හේතුව: LinkedList හි සෑම අංගයක්ම ලැයිස්තුවේ ඇති අසල්වැසි මූලද්‍රව්‍ය දෙකටම යොමු වන දර්ශක දෙකක් (ලිපින) පවත්වා ගනී. එබැවින් ඉවත් කිරීමට අවශ්‍ය වන්නේ ඉවත් කිරීමට යන නෝඩයේ අසල්වැසි නෝඩ් දෙකෙහි (මූලද්‍රව්‍ය) දර්ශකයේ පිහිටීම වෙනස් කිරීම පමණි. ArrayList හි ඉවත් කරන ලද මූලද්‍රව්‍යය මඟින් නිර්මාණය කරන ලද අවකාශය පිරවීම සඳහා සියලු අංග මාරු කළ යුතුය.

3) Inserts Performance: LinkedListඑකතු කිරීමේ ක්‍රමය මඟින් O(1)කාර්ය සාධනය ArrayListලබා දෙන O(n)අතර නරකම අවස්ථාවක දී ලබා දේ. ඉවත් කිරීම සඳහා පැහැදිලි කර ඇති ආකාරයටම හේතුව සමාන වේ.

4) මූලද්‍රව්‍ය දත්ත සහ අසල්වැසි නෝඩ් සඳහා දර්ශක දෙකක් පවත්වා ගෙන යන Memory Overhead: ArrayListඅතර දර්ශක සහ මූලද්‍රව්‍ය දත්ත LinkedListනඩත්තු කරයි

එබැවින් සංසන්දනාත්මකව LinkedList හි මතක පරිභෝජනය ඉහළ මට්ටමක පවතී.

මෙම පංති අතර සමානකම් කිහිපයක් පහත පරිදි වේ:

• ArrayList සහ LinkedList යන දෙකම ලැයිස්තු අතුරුමුහුණත ක්‍රියාත්මක කිරීමකි.
• ඔවුන් දෙදෙනාම මූලද්‍රව්‍ය ඇතුළත් කිරීමේ අනුපිළිවෙල පවත්වා ගෙන යන අතර එයින් අදහස් කරන්නේ අරේලිස්ට් සහ ලින්ක්ඩ්ලිස්ට් මූලද්‍රව්‍ය ප්‍රදර්ශනය කරන අතර ප්‍රති result ල කට්ටලය ලැයිස්තුවට මූලද්‍රව්‍ය ඇතුළත් කළ අනුපිළිවෙලම වේ.
• මෙම පංති දෙකම සමමුහුර්ත නොවන අතර Collections.synchronizedList ක්‍රමය භාවිතා කිරීමෙන් පැහැදිලිවම සමමුහුර්ත කළ හැකිය.
• මෙම iteratorසහ listIteratorමේ පංති විසින් ලබා ඇත fail-fast(ලැයිස්තුව ව හය හරහා මිස කිසිම ආකාරයකින් එම iterator නිර්මාණය වූ පසු ඕනෑම අවස්ථාවක වෙනස් නම් iterator’s, එම iterator ඇත ම හෝ ඉවත් ක්රම එකතු throwවූ ConcurrentModificationException).

LinkedList භාවිතා කළ යුත්තේ කවදාද සහ ArrayList භාවිතා කරන්නේ කවදාද?

• ඉහත විස්තර කර ඇති පරිදි ඇතුළු කිරීමේ හා ඉවත් කිරීමේ මෙහෙයුම් සාපේක්ෂව හොඳ කාර්ය සාධනයක් (O(1))ලබා LinkedListදෙයි ArrayList(O(n)).

  එබැවින් යෙදුම තුළ නිතර එකතු කිරීම සහ මකා දැමීමේ අවශ්‍යතාවයක් තිබේ නම් ලින්ක්ඩ්ලිස්ට් හොඳම තේරීම වේ.

• සෙවුම් ( get method) මෙහෙයුම් වේගවත් Arraylist (O(1))නමුත් ක්‍රියාත්මක නොවේLinkedList (O(n))

  එබැවින් අඩු එකතු කිරීම් සහ ඉවත් කිරීම් මෙහෙයුම් සහ තවත් සෙවුම් මෙහෙයුම් අවශ්‍යතා තිබේ නම්, අරා ලැයිස්තු ඔබේ හොඳම ඔට්ටුව වනු ඇත.

ArrayList හි ක්‍රියාකාරිත්වය ලබා ගැනීම (i) LinkedList ට වඩා වේගවත්ය, මන්ද:
ArrayList: ලැයිස්තු අතුරුමුහුණතේ
ප්‍රතිනිර්මාණය කළ හැකි -අරාව ක්‍රියාත්මක කිරීම LinkedList: ලැයිස්තුව හා Deque අතුරුමුහුණත් ද්විත්ව සම්බන්ධිත ලැයිස්තු ක්‍රියාත්මක කිරීම

ලැයිස්තුවට දර්ශකය ගෙන යන මෙහෙයුම් මඟින් ආරම්භයේ සිට අවසානය දක්වා, නිශ්චිත දර්ශකයට වඩා කවරක් වුවද ලැයිස්තුව හරහා ගමන් කරයි.

1) යටින් පවතින දත්ත ව්‍යුහය

ArrayList සහ LinkedList අතර පළමු වෙනස වන්නේ ArrayList සඳහා Array සහාය දක්වන අතර LinkedList LinkedList හි පිටුබලයයි. මෙය කාර්ය සාධනයේ තවදුරටත් වෙනස්කම් වලට තුඩු දෙනු ඇත.

2) LinkedList විසින් Deque ක්‍රියාත්මක කරයි

ArrayList සහ LinkedList අතර ඇති තවත් වෙනසක් නම්, ලැයිස්තු අතුරුමුහුණත හැරුණු විට, LinkedList විසින් Deque අතුරුමුහුණත ද ක්‍රියාත්මක කරන අතර, එය එකතු කිරීමේ () සහ ඡන්ද විමසීම් () සහ තවත් Deque කාර්යයන් කිහිපයක් සඳහා පළමු මෙහෙයුම් වලදී ප්‍රථමයෙන් සපයයි. 3) අරා ලැයිස්තුවේ මූලද්‍රව්‍ය එකතු කිරීම අරේලිස්ට් හි මූලද්‍රව්‍යය එකතු කිරීම ඕ (1) මෙහෙයුම වන්නේ එය අරේ ප්‍රමාණය නැවත අවුලුවන්නේ නැතිනම් එය O (ලොග් (n)) බවට පත්වන අතර අනෙක් අතට මූලද්‍රව්‍යයක් එකතු කිරීම LinkedList යනු O (1) මෙහෙයුමකි, එයට කිසිදු සංචාලනයක් අවශ්‍ය නොවේ.

4) ස්ථානයකින් මූලද්රව්යයක් ඉවත් කිරීම

කිසියම් දර්ශකයකින් මූලද්‍රව්‍යයක් ඉවත් කිරීම සඳහා උදා: ඉවත් කිරීම (දර්ශකය) ඇමතීමෙන්, අරේලිස්ට් විසින් පිටපත් කිරීමේ ක්‍රියාවලියක් සිදු කරන අතර එය O (n) ට ආසන්න වන අතර LinkedList එම ස්ථානයට ගමන් කළ යුතු අතර එය O (n / 2) බවට පත් කරයි. , එය සමීපත්වය මත පදනම්ව දෙපැත්තෙන්ම ගමන් කළ හැකි බැවින්.

5) ArrayList හෝ LinkedList හරහා අනුකරණය කිරීම

අනුකරණය යනු LinkedList සහ ArrayList යන දෙකටම O (n) මෙහෙයුම වන අතර n යනු මූලද්‍රව්‍ය ගණනකි.

6) ස්ථානයකින් මූලද්රව්ය ලබා ගැනීම

ලබා ගැනීමේ (දර්ශක) මෙහෙයුම අරේලිස්ට් හි O (1) වන අතර එහි O (n / 2) LinkedList හි ඇත, එම ප්‍රවේශය තෙක් ගමන් කළ යුතු බැවින්. බිග් ඕ අංකනයේ O (n / 2) යනු O (n) පමණක් වුවද, අපි එහි නියතයන් නොසලකා හරිමු.

7) මතකය

LinkedList විසින් දත්ත ගබඩා කිරීම සඳහා ස්ථිතික කැදැලි පන්තියක් වන එන්ට්‍රි, එතීෙම් වස්තුවක් භාවිතා කරයි.

එබැවින් අරාව එක් අරාවකින් තවත් අරා වෙත අන්තර්ගතය පිටපත් කරන විට නැවත ප්‍රමාණයේ ක්‍රියාකාරිත්වය සිදු කරන අවස්ථාව හැර, සම්බන්ධක ලැයිස්තුවට වඩා අරේලිස්ට් සම්බන්ධයෙන් මතක අවශ්‍යතාවය අඩු බව පෙනේ.

අරාව ප්‍රමාණවත් තරම් විශාල නම්, එම අවස්ථාවේදී විශාල මතකයක් ගත හැකි අතර කසළ එකතු කිරීම අවුලුවන අතර එමඟින් ප්‍රතිචාර කාලය මන්දගාමී විය හැකිය.

ArrayList එදිරිව LinkedList අතර ඇති ඉහත සියලු වෙනස්කම් වලින්, ඔබ ඉවත් කිරීම () හෝ ලබා ගැනීම () ලබා ගැනීමට වඩා නිතර එකතු කිරීමේ () මෙහෙයුමක් කරන විට හැර, සෑම අවස්ථාවකම පාහේ LinkedList ට වඩා ArrayList වඩා හොඳ තේරීමක් බව පෙනේ.

අරේලිස්ට් වලට වඩා සම්බන්ධිත ලැයිස්තුවක් වෙනස් කිරීම පහසුය, විශේෂයෙන් ඔබ ආරම්භයේ හෝ අවසානයේ සිට අංග එකතු කිරීම හෝ ඉවත් කිරීම කරන්නේ නම්, සම්බන්ධිත ලැයිස්තුව අභ්‍යන්තරව එම තනතුරු පිළිබඳ සඳහනක් තබා ඇති අතර ඒවා O (1) වේලාවට ප්‍රවේශ විය හැකිය.

වෙනත් වචන වලින් කිවහොත්, ඔබට මූලද්‍රව්‍ය එකතු කිරීමට අවශ්‍ය ස්ථානයට ලඟා වීමට සම්බන්ධිත ලැයිස්තුව හරහා ගමන් කිරීම අවශ්‍ය නොවේ, එවැනි අවස්ථාවකදී එකතු කිරීම O (n) මෙහෙයුමක් බවට පත්වේ. උදාහරණයක් ලෙස, සම්බන්ධිත ලැයිස්තුවක් මැද මූලද්‍රව්‍යයක් ඇතුළු කිරීම හෝ මකා දැමීම.

මගේ මතය අනුව, ජාවා හි බොහෝ ප්‍රායෝගික අරමුණු සඳහා LinkedList හරහා ArrayList භාවිතා කරන්න.

මා මෙහි දුටු එක් පරීක්ෂණයකින් එක් වරක් පමණක් පරීක්ෂණය පවත්වයි. නමුත් මා දැක ඇති දෙය නම්, ඔබ මෙම පරීක්ෂණ බොහෝ වාරයක් ධාවනය කළ යුතු අතර අවසානයේ ඔවුන්ගේ කාලය අභිසාරී වනු ඇත. මූලික වශයෙන් JVM උණුසුම් කිරීමට අවශ්යයි. මගේ විශේෂිත භාවිත අවස්ථාව සඳහා අයිතම 500 ක් දක්වා වර්ධනය වන ලැයිස්තුවකට අයිතම එකතු කිරීමට / ඉවත් කිරීමට මට අවශ්‍ය විය. මගේ පරීක්ෂණ වලදී එන්එස් 50,000 ක් පමණ පැමිණ එන්එස් 90,000 ක් පමණ පැමිණීමත් LinkedListසමඟ වේගයෙන් එළියට ආවා ... දෙන්න හෝ ගන්න. පහත කේතය බලන්න.LinkedListArrayList

public static void main(String[] args) {
    List<Long> times = new ArrayList<>();
    for (int i = 0; i < 100; i++) {
        times.add(doIt());
    }
    System.out.println("avg = " + (times.stream().mapToLong(x -> x).average()));
}

static long doIt() {
    long start = System.nanoTime();
    List<Object> list = new LinkedList<>();
    //uncomment line below to test with ArrayList
    //list = new ArrayList<>();
    for (int i = 0; i < 500; i++) {
        list.add(i);
    }

    Iterator it = list.iterator();
    while (it.hasNext()) {
        it.next();
        it.remove();
    }
    long end = System.nanoTime();
    long diff = end - start;
    //uncomment to see the JVM warmup and get faster for the first few iterations
    //System.out.println(diff)
    return diff;
}

ඉවත් කිරීම () සහ ඇතුළු කිරීම () යන දෙකම අරා ලැයිස්තු සහ සම්බන්ධක ලැයිස්තු සඳහා O (n) හි ධාවන කාල කාර්යක්ෂමතාවයක් ඇත. කෙසේ වෙතත්, රේඛීය සැකසුම් කාලය සඳහා හේතුව වෙනස් හේතු දෙකකින් පැමිණේ:

අරාවලිස්ට් එකක, ඔබ ඕ (1) හි මූලද්‍රව්‍යයට පිවිසෙයි, නමුත් ඇත්ත වශයෙන්ම යමක් ඉවත් කිරීම හෝ ඇතුළත් කිරීම මඟින් එය ඕ (එන්) බවට පත් වන්නේ පහත සඳහන් සියලු අංග වෙනස් කළ යුතු බැවිනි.

සම්බන්ධිත ලැයිස්තුවක, ඇත්ත වශයෙන්ම අපේක්ෂිත මූලද්‍රව්‍යයට ලඟා වීමට O (n) අවශ්‍ය වේ, මන්ද අප අපේක්ෂිත දර්ශකය වෙත ළඟා වන තුරු ආරම්භයේදීම ආරම්භ කළ යුතු බැවිනි. ඇත්ත වශයෙන්ම ඉවත් කිරීම හෝ ඇතුළත් කිරීම නියත ය, මන්ද අපට වෙනස් කළ යුත්තේ ඉවත් කිරීම සඳහා යොමු 1 ක් සහ ඇතුළු කිරීම සඳහා යොමු 2 ක් පමණි.

ඇතුළත් කිරීම සහ ඉවත් කිරීම සඳහා වේගවත් වන්නේ දෙකෙන් කුමන එකක්ද යන්න සිදුවන්නේ කොතැනද යන්න මතය. අපි ආරම්භයට සමීප නම්, සබැඳි ලැයිස්තුව වේගවත් වනු ඇත, මන්ද අපට සාපේක්ෂව මූලද්‍රව්‍ය කිහිපයක් හරහා යා යුතු බැවිනි. අප අවසානයට සමීප නම් අරේලිස්ට් එකක් වේගවත් වනු ඇත, මන්ද අප නිරන්තර වේලාවට එහි පැමිණෙන අතර එය අනුගමනය කළ යුතු ඉතිරි අංග කිහිපයක් පමණක් වෙනස් කළ යුතුය. හරියටම මධ්‍යයේ සිදු කළ විට සම්බන්ධක ලැයිස්තුව වේගවත් වනුයේ n මූලද්‍රව්‍ය හරහා ගමන් කිරීම n අගයන්ට වඩා වේගවත් වන බැවිනි.

පාරිතෝෂිකය: අරේලිස්ට් සඳහා මෙම ක්‍රම දෙක O (1) සෑදීමට ක්‍රමයක් නොමැති අතර, ඇත්ත වශයෙන්ම මෙය සබැඳි ලැයිස්තු තුළ කළ හැකි ක්‍රමයක් තිබේ. අපගේ ලැයිස්තුවේ අංග ඉවත් කිරීම සහ ඇතුළත් කිරීම යන සමස්ත ලැයිස්තුව හරහා යාමට අපට අවශ්‍ය යැයි කියමු. සාමාන්‍යයෙන්, ඔබ ආරම්භයේ සිටම එක් එක් මූලද්‍රව්‍ය සඳහා සබැඳි ලැයිස්තුව භාවිතා කරමින් ආරම්භ කරනු ඇත, අපට ඉටරේටරයක් ​​සමඟ වැඩ කරන වත්මන් මූලද්‍රව්‍යය "සුරැකීමට" හැකිය. සම්බන්ධක ලැයිස්තුවේ වැඩ කිරීමේදී ඉවත් කිරීමේ () සහ ඇතුළත් කිරීමේ () සඳහා O (1) කාර්යක්ෂමතාවයක් අපට ලැබේ. එය එකම කාර්ය සාධන ප්‍රතිලාභයක් බවට පත් කිරීම, අරා ලැයිස්තු වලට වඩා සම්බන්ධිත ලැයිස්තුවක් සැමවිටම හොඳ තැනක් බව මම දනිමි.

ArrayList සාරාංශ ලැයිස්තුව දිගු කර ලැයිස්තු අතුරුමුහුණත ක්‍රියාත්මක කරයි. ArrayList යනු ගතික අරාවකි.
අරා වල අඩුපාඩු මඟහරවා ගැනීම සඳහා එය මූලික වශයෙන් නිර්මාණය කරන ලද්දක් බව පැවසිය හැකිය

.
කාර්ය සාධනය
arraylist.get()O (1) වන අතර linkedlist.get()O (n)
arraylist.add()O (1) වන අතර linkedlist.add()0 (1)
arraylist.contains()O (n) වන අතර linkedlist.contains()O (n)
arraylist.next()O (1) වන අතර linkedlist.next()O (1)
arraylist.remove()O (n) වේ. ඇති ෙහයින්ද linkedlist.remove()සාමාන්ය (1) වන
arraylist දී
iterator.remove()සාමාන්ය (n) වේ
දී linkedlist ෙහයින්ද,
iterator.remove()සාමාන්ය (1) වන