জাভাতে লিংকডলিস্ট ওভার অ্যারেলিস্ট কখন ব্যবহার করবেন?

Question

আমি সর্বদা সহজভাবে ব্যবহার করার জন্য এক হয়েছি:

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

আমি ইন্টারফেসটি বহনযোগ্যতার জন্য টাইপের নাম হিসাবে ব্যবহার করি , যাতে আমি যখন এই জাতীয় প্রশ্নগুলি জিজ্ঞাসা করি তখন আমি আমার কোডটি পুনরায় কাজ করতে পারি।

কখন এবং তদ্বিপরীত LinkedListব্যবহার করা উচিত ArrayList?

Comments

আরও দেখুন: অ্যারে বনাম লিঙ্কযুক্ত-তালিকা

— হক্কে পার্কার

শুধু LinkedList লেখক থেকে উদ্ধৃতি দেখতে stackoverflow.com/a/42529652/2032701 এবং আপনার সমস্যা বাস্তবসম্মত ইন্দ্রিয় পাবেন।

— রুসলান

Answer 1

সারাংশ ArrayList সঙ্গে ArrayDequeএ বাঞ্ছনীয় হয় অনেক চেয়ে বেশি ব্যবহার-মামলা LinkedList। আপনি যদি নিশ্চিত না হন - তবে শুরু করুন ArrayList।

---

LinkedListএবং ArrayListতালিকা ইন্টারফেসের দুটি পৃথক বাস্তবায়ন। LinkedListদ্বিগুণ-লিঙ্কযুক্ত তালিকার সাথে এটি প্রয়োগ করে। ArrayListএটি একটি গতিশীল পুনরায় আকার দেওয়ার অ্যারে দিয়ে প্রয়োগ করে।

স্ট্যান্ডার্ড লিঙ্কযুক্ত তালিকা এবং অ্যারের ক্রিয়াকলাপগুলির মতো বিভিন্ন পদ্ধতির আলাদা আলাদা অ্যালগোরিদমিক রানটাইম থাকবে।

জন্য LinkedList<E>

• get(int index)হয় হে (ঢ) (সঙ্গে এন / 4 গড়ে পদক্ষেপ), কিন্তু হে (1) যখন index = 0বা index = list.size() - 1(এই ক্ষেত্রে, আপনার কাছে ব্যবহার করতে পারেন getFirst()এবং getLast())। এর অন্যতম প্রধান সুবিধা LinkedList<E>
• add(int index, E element)হয় হে (ঢ) (সঙ্গে এন / 4 গড়ে পদক্ষেপ), কিন্তু হে (1) যখন index = 0বা index = list.size() - 1(এই ক্ষেত্রে, আপনার কাছে ব্যবহার করতে পারেন addFirst()এবং addLast()/ add())। এর অন্যতম প্রধান সুবিধা LinkedList<E>
• remove(int index)হয় হে (ঢ) (সঙ্গে এন / 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) এবং খারাপ ক্ষেত্রে এন / 2 পদক্ষেপের (তালিকার মাঝখানে) প্রয়োজন}

জন্য ArrayList<E>

• get(int index)হয় হে (1) । এর প্রধান সুবিধা ArrayList<E>
• add(E element)হয় হে (1) amortized কিন্তু হে (ঢ) খারাপ-কেস থেকে অ্যারের আকার পরিবর্তন এবং অনুলিপি করা আবশ্যক
• add(int index, E element)হয় হে (ঢ) (সঙ্গে এন / 2 গড়ে পদক্ষেপ)
• remove(int index)হয় হে (ঢ) (সঙ্গে এন / 2 গড়ে পদক্ষেপ)
• Iterator.remove()হয় হে (ঢ) (সঙ্গে এন / 2 গড়ে পদক্ষেপ)
• ListIterator.add(E element)হয় হে (ঢ) (সঙ্গে এন / 2 গড়ে পদক্ষেপ)

^{নোট: অপারেশন অনেক প্রয়োজন এন / 2 গড়, উপর পদক্ষেপ ধ্রুবক সেরা ক্ষেত্রে পদক্ষেপ (তালিকা শেষে) সংখ্যা, এন সবচেয়ে খারাপ ক্ষেত্রে পদক্ষেপ (তালিকা শুরুতে)}

LinkedList<E>পুনরাবৃত্তকারীদের ব্যবহার করে ধ্রুবক-সময় সন্নিবেশ বা অপসারণের অনুমতি দেয় তবে কেবলমাত্র উপাদানগুলির ক্রমবর্ধমান অ্যাক্সেস। অন্য কথায়, আপনি তালিকায় এগিয়ে বা পিছনের দিকে যেতে পারেন তবে তালিকার কোনও অবস্থান সন্ধান করতে তালিকার আকারের সাথে আনুপাতিক সময় লাগে। জাভাডোক বলেছে যে " তালিকাগুলির তালিকা অনুসারে যে অপারেশনগুলি সূচনা বা শেষের দিক থেকে তালিকাটি পেরিয়ে যাবে, যেদিকেই কাছাকাছি থাকবে" , সুতরাং এই পদ্ধতিগুলি O (n) ( n / 4 পদক্ষেপ), যদিও ও (1) এর জন্য index = 0।

ArrayList<E>অন্যদিকে, দ্রুত এলোমেলো পড়ার অ্যাক্সেসের অনুমতি দিন, যাতে আপনি ধ্রুব সময়ে যে কোনও উপাদান দখল করতে পারেন। তবে যে কোনও জায়গা থেকে যোগ করা বা অপসারণ করা হলেও শেষের জন্য সমস্ত পরবর্তী উপাদানগুলি সরিয়ে নেওয়া দরকার হয় হয় খোলার জন্য বা ফাঁক পূরণ করতে। এছাড়াও, যদি আপনাকে অন্তর্নিহিত অ্যারের ধারণক্ষমতা চেয়ে বেশি উপাদান যোগ করুন, একটি নতুন অ্যারে (1.5 বার সাইজ) বরাদ্দ করা হয়, এবং পুরাতন অ্যারের নতুন এক কপি হয়, তাই একটি যোগ ArrayListহয় হে (ঢ) খারাপ মধ্যে কেস কিন্তু গড় স্থির।

সুতরাং যে কাজগুলি আপনি করতে চান তার উপর নির্ভর করে আপনার সেই অনুযায়ী প্রয়োগগুলি বেছে নেওয়া উচিত। উভয় ধরণের তালিকার উপরে আইট্রেট করা কার্যত সমান সস্তা। (একটির উপরে আইট্রেট ArrayListকরা প্রযুক্তিগতভাবে দ্রুত, তবে আপনি যদি সত্যিই পারফরম্যান্স-সংবেদনশীল কিছু না করেন তবে আপনার এটি নিয়ে চিন্তা করা উচিত নয় - এগুলি উভয়ই ধ্রুবক))

LinkedListউপাদানগুলি সন্নিবেশ করানোর জন্য এবং সরানোর জন্য আপনি বিদ্যমান পুনরাবৃত্তিগুলি পুনরায় ব্যবহার করার সময় উত্থাপিত ব্যবহারের প্রধান সুবিধা । এই অপারেশনগুলি কেবল স্থানীয়ভাবে তালিকা পরিবর্তন করে ও (1) এ করা যেতে পারে । একটি অ্যারের তালিকায় অ্যারের বাকী অংশগুলি সরানো প্রয়োজন (অর্থাত অনুলিপি করা)। অন্যদিকে, খারাপ অবস্থার জন্য ও (এন) ( এন / ২ পদক্ষেপ) LinkedListএর লিঙ্কগুলি অনুসরণ করার উপায় সন্ধান করা , অন্যদিকে কাঙ্ক্ষিত অবস্থানে গাণিতিকভাবে গণনা করা যেতে পারে এবং ও (1) এ অ্যাক্সেস করা যায় ।ArrayList

LinkedListযখন আপনি তালিকার শীর্ষস্থানীয় যোগ করুন বা সরিয়ে ফেলবেন তখন ব্যবহার করার আরেকটি সুবিধা হ'ল যেহেতু এই ক্রিয়াকলাপগুলি হ'ল (1) , যখন তারা ও (এন) হয় ArrayList। নোট করুন যে মাথা থেকে যোগ এবং অপসারণের জন্য ArrayDequeএকটি ভাল বিকল্প হতে পারে LinkedList, তবে এটি একটি নয় List।

এছাড়াও, আপনার যদি বড় তালিকা থাকে তবে মনে রাখবেন যে মেমরির ব্যবহারটিও আলাদা also LinkedListপরবর্তী এবং পূর্ববর্তী উপাদানগুলির পয়েন্টারগুলিও সঞ্চিত হওয়ায় একটির প্রতিটি উপাদানের আরও ওভারহেড থাকে। ArrayListsএই ওভারহেড নেই তবে ArrayListsসামর্থ্যের জন্য যতটুকু বরাদ্দ করা হয়েছে তত পরিমাণ স্মৃতি গ্রহণ করুন, উপাদানগুলি আসলে যুক্ত করা হয়েছে কিনা তা বিবেচনা না করেই।

এর ডিফল্ট প্রাথমিক ক্ষমতাটি ArrayListবেশ ছোট (জাভা 1.4 - 1.8 থেকে 10)। তবে অন্তর্নিহিত বাস্তবায়ন একটি অ্যারে হওয়ায় আপনি প্রচুর উপাদান যুক্ত করলে অ্যারেটিকে অবশ্যই পুনরায় আকার দিতে হবে। আপনি প্রচুর পরিমাণে উপাদান যুক্ত করতে চলেছেন যখন আপনি পুনর্নির্মাণের উচ্চ ব্যয়টি এড়াতে ArrayListউচ্চতর প্রাথমিক ক্ষমতা সহ এটি নির্মাণ করুন ।

Comments

সন্নিবেশ ব্যয়ের কথা উল্লেখ করতে ভুলে গেছেন। লিংকডলিস্টে একবার আপনার সঠিক অবস্থানটি আসার পরে সন্নিবেশনের জন্য ও (1) ব্যয় হয়, যখন একটি অ্যারেলিস্টে এটি ও (এন) এর উপরে যায় - সন্নিবেশ বিন্দুর সমস্ত উপাদান সরিয়ে নিতে হবে।

— ডেভিড রদ্রিগেজ - ড্রিবিস

ভেক্টরের ব্যবহার সম্পর্কিত: সত্যিকার অর্থে ভেক্টরের পিছনে পড়ার দরকার নেই। এটি করার উপায়টি হল আপনার পছন্দের তালিকা বাস্তবায়ন এবং এটি একটি সিঙ্ক্রোনাইজড র‌্যাপার দেওয়ার জন্য সিঙ্ক্রোনাইজডলিস্টে কল। দেখুন: java.sun.com

— রায়ান কক্স

না, লিংকডলিস্টের জন্য, পজিশনটি জানা থাকলেও পেতে এখনও ও (এন) পাবেন, কারণ সেই অবস্থানটিতে পৌঁছানোর জন্য অন্তর্নিহিত বাস্তবায়নটিকে সেই অবস্থানটির মান পেতে লিংক তালিকার "পরবর্তী" পয়েন্টারগুলি হাঁটাতে হবে। এলোমেলো অ্যাক্সেসের মতো কোনও জিনিস নেই। পজিশন 2 এর জন্য, পয়েন্টারগুলি হাঁটা সস্তা হতে পারে, তবে পজিশনের জন্য 1 মিলিয়ন, এত সস্তা নয়। মুল বক্তব্যটি হ'ল এটি অবস্থানের সাথে আনুপাতিক, যার অর্থ এটি ও (এন)।

— জোনাথন ট্রান

@ কেভিন এটি মেমরিটি "একত্রে কাছাকাছি" থাকার বিষয়টি বিবেচনা করতে পারে। হার্ডওয়্যার L1 বা L2 ক্যাশে দ্রুত স্ট্যাটিক র‌্যামে মেমরির (ডায়নামিক র‌্যাম) সংক্ষিপ্ত ব্লকগুলি ক্যাশে করবে। তত্ত্ব এবং বেশিরভাগ সময় ব্যবহারিকভাবে, স্মৃতিটিকে এলোমেলো অ্যাক্সেস হিসাবে বিবেচনা করা যেতে পারে। তবে বাস্তবে, ক্রমানুসারে মেমরির মাধ্যমে পড়াটি এলোমেলো ক্রমের চেয়ে কিছুটা দ্রুত হবে। একটি পারফরম্যান্স-সমালোচনামূলক লুপ জন্য, এটি গুরুত্বপূর্ণ হতে পারে। তারা এটিকে "স্থানীয় স্থান" বা রেফারেন্সের লোকেশন বলে ।

— জোনাথন ট্রান

O(n/2)বা তেমন কোনও জিনিস নেই O(n/4)। বড় হে সংকেত আপনাকে জানায় যে কীভাবে একটি অপারেশন বৃহত্তর এন দিয়ে স্কেল করে । এবং একটি অপারেশনগুলির প্রয়োজনীয় পদক্ষেপগুলি সঠিকভাবে অপারেশনগুলির মতো প্রয়োজনীয় পদক্ষেপগুলির মতো স্কেল করে , যা কারণ হ'ল ধ্রুবক সমান বা উপাদানগুলি সরানো হয়। এবং উভয় ন্যায্য । এবং যাইহোক যাইহোক বিভিন্ন ধ্রুবক কারণ রয়েছে, সুতরাং এটির মধ্যে একটির সাথে অন্যের তুলনা করার মত ধারণা তৈরি হবে না , উভয়ই কেবল রৈখিক স্কেলিং অপারেশনকে বোঝায়। n/2nO(n/2)O(n/4)O(n)LinkedListArrayListO(n/2)O(n/4)

— হলগার

Answer 2

সেটা অনেক দূরে, কেউ কিছু করে একটি সাধারণ ঐক্যমত্য ছাড়া এই তালিকাগুলি প্রতিটি স্মৃতির পদাঙ্ক সুরাহা হয়েছে বলে মনে হয় LinkedList"আরো অনেক" হয় চেয়ে একটি ArrayListতাই আমি কিছু প্রকট ঠিক কত উভয় তালিকায় এন নাল রেফারেন্সের জন্য পর্যন্ত সময় লাগতে ক্রান্চিং সংখ্যা করেনি।

যেহেতু রেফারেন্সগুলি তাদের আপেক্ষিক সিস্টেমে 32 বা 64 বিট (নাল হয়ে গেলেও) তাই আমি 32 এবং 64 বিটের জন্য 4 সেট ডেটা LinkedListsএবং অন্তর্ভুক্ত করেছিArrayLists ।

দ্রষ্টব্য:ArrayList লাইনগুলির জন্য প্রদর্শিত আকারগুলি ছাঁটাইযুক্ত তালিকার জন্য - অনুশীলনে, একটিতে ব্যাকিং অ্যারের সক্ষমতা ArrayListতার বর্তমান উপাদান গণনার চেয়ে সাধারণত বড়।

নোট 2: (ধন্যবাদ বিঅনরপকে ধন্যবাদ) যেহেতু কমপ্রেসডহপগুলি এখন মধ্য জেডিকে 6 এবং তারপরে ডিফল্ট, 64৪-বিট মেশিনের জন্য নীচের মানগুলি মূলত তাদের 32-বিট অংশের সাথে মেলে, যদি না আপনি বিশেষভাবে এটি বন্ধ করে দেন।

---

---

ফলাফলটি পরিষ্কারভাবে দেখায় যে এর LinkedListচেয়ে অনেক বেশিArrayList বিশেষত খুব উচ্চতর উপাদান গণনার । স্মৃতি যদি একটি ফ্যাক্টর হয় তবে এর থেকে পরিষ্কার হয়ে যান LinkedLists।

আমি যে সূত্রগুলি অনুসরণ করেছি তা অনুসরণ করুন, আমি কোনও ভুল করেছি কিনা তা আমাকে জানান এবং আমি এটি ঠিক করে দেব। 'বি' 32 বা 64 বিট সিস্টেমের জন্য 4 বা 8 হয় এবং 'এন' উপাদানগুলির সংখ্যা। মোডগুলির কারণটি নোট করুন কারণ জাভাতে সমস্ত বস্তু 8 টি বাইট স্পেসের একাধিক গ্রহণ করবে তা নির্বিশেষে এটি সমস্ত ব্যবহৃত হয় কিনা।

ArrayList:

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)

Comments

দেখতে খুব আকর্ষণীয় যে লিংকডলিস্টে একটি একক উপাদান সংরক্ষণের জন্য অ্যারেলিস্টের মতো মেমরির প্রয়োজন। কত অনর্থক! আপনি যদি আপনার উদাহরণটি -XX: + ইউজকম্প্রেসড ওপস দিয়ে চালান তবে কি হবে?

— jontejj

আপনার গণিতের সমস্যাটি হ'ল আপনার গ্রাফটি প্রভাবটিকে অত্যধিকভাবে বাড়িয়ে তোলে। আপনি এমন মডেলিং করছেন যা প্রত্যেকটিতে কেবল একটি int, তাই 4 বা 8 বাইট ডেটা থাকে। লিঙ্কযুক্ত তালিকায় ওভারহেডের মূলত 4 টি "শব্দ" রয়েছে। আপনার গ্রাফটি এমনভাবে ছাপ দেয় যে লিঙ্কযুক্ত তালিকাগুলি অ্যারে তালিকাগুলির "পাঁচবার" ব্যবহার করে। এটা ভুল. ওভারহেডটি প্রতি বস্তুর জন্য 16 বা 32 বাইট হয়, একটি অ্যাডিটিভ অ্যাডজাস্টমেন্ট হিসাবে, কোনও স্কেলিং ফ্যাক্টর নয়।

— Hunnicutt

অ্যারেলিস্ট / লিংকডলিস্ট / নোডের কোনও কিছুইতেই কেবল কোনও ইনট থাকে না, তাই আপনি সেখানে যা বলছেন তা আমি পেতে পারি না। আমি 'অবজেক্ট ওভারহেড' স্পষ্ট করার জন্য 'অবজেক্ট শিরোলেখ' লিখেছি - সিস্টেম নির্বিশেষে প্রতিটি বস্তুর জন্য একটি 8 বাইট শিরোলেখ আছে, এবং হ্যাঁ লিঙ্কডলিস্টের সমস্ত নোড অবজেক্টগুলিকে অন্তর্ভুক্ত করা হয়েছে, যা আমি যতদূর পারি সঠিকভাবে গণনা করা হচ্ছে বলুন। ঘটনাক্রমে, এটি আবার দেখার জন্য, আমি আমার গণিতের সাথে লিংকডলিস্টে আরও বেশ কয়েকটি সমস্যা পেয়েছি যা আসলে এটি ভাগ করে দিয়েছে এবং অ্যারেলিস্টকে আরও খারাপ করেছে । আমি এটি আপডেট করতে পেরে খুশি তাই দয়া করে স্পষ্ট করে এবং বিশদভাবে ফুটিয়ে তুলতে দ্বিধা করবেন না।

— নিউমারন

এটি লক্ষ করা উচিত যে CompressedOopsসমস্ত সাম্প্রতিক জেডিকে (7, 8 এবং কয়েক বছরের জন্য 6 এর আপডেট) -এ এখন ডিফল্ট, সুতরাং আপনি স্পষ্টভাবে সংকোচিত ওপস বন্ধ না করে 64৪-বিট কোনও আকার ArrayListবা LinkedListআকারে কোনও তাত্পর্য ফেলবে না unless কিছু কারণ.

— BeeOnRope

@ জঞ্জেজেজ ডিফল্ট ক্ষমতা বৃদ্ধি 50%, সুতরাং আপনি যখন ArrayListপ্রাথমিক ক্ষমতাকে নির্দিষ্ট করে না দিয়ে একটি পপুলেট করেন , তখনও এটি একটি এর চেয়ে উল্লেখযোগ্যভাবে কম স্মৃতি ব্যবহার করবে LinkedList।

— হলার

Answer 3

ArrayListআপনি কি চান LinkedListপ্রায় সর্বদা একটি (পারফরম্যান্স) বাগ।

কেন LinkedListস্তন্যপান:

• এটি প্রচুর ছোট মেমোরি অবজেক্ট ব্যবহার করে এবং তাই প্রক্রিয়া জুড়ে পারফরম্যান্সকে প্রভাবিত করে।
• প্রচুর ছোট ছোট বস্তু ক্যাশে-স্থানীয়তার জন্য খারাপ।
• যে কোনও সূচকযুক্ত অপারেশনের জন্য ট্র্যাভারসাল প্রয়োজন, যার অর্থ ও (এন) রয়েছে। এটি উত্স কোডে সুস্পষ্ট নয়, যার ফলে অ্যালগোরিদম হে (এন) ArrayListব্যবহার করা হয়েছে তার চেয়ে ধীর হয়ে যায় ।
• ভাল পারফরম্যান্স পাওয়া কৌতুকপূর্ণ।
• এমনকি যখন বিগ-ও পারফরম্যান্সটি একই রকম হয় ArrayList, সম্ভবত এটি সম্ভবত উল্লেখযোগ্যভাবে ধীর হতে চলেছে।
• এটি LinkedListউত্সটি দেখতে ব্যঙ্গ করছে কারণ এটি সম্ভবত ভুল পছন্দ।

Comments

দুঃখিত। আপনাকে চিহ্নিত লিঙ্কডলিস্ট চুষে না। এমন পরিস্থিতি রয়েছে যেখানে লিঙ্কডলিস্ট হ'ল সঠিক ক্লাস ব্যবহার করা। আমি সম্মত হই যে এমন অনেকগুলি পরিস্থিতি নেই যেখানে অ্যারেলিস্টের চেয়ে ভাল তবে এটি বিদ্যমান। যারা নির্বোধ কাজ করে তাদের শিক্ষিত করুন!

— ডেভিড টার্নার

এর জন্য আপনাকে প্রচুর ডাউন-ভোট পেয়েছি বলে দুঃখিত। জাভার লিঙ্কডলিস্ট ব্যবহার করার সত্যিই খুব কম কারণ রয়েছে। খারাপ পারফরম্যান্সের পাশাপাশি এটি অন্যান্য কংক্রিট তালিকার শ্রেণীর তুলনায় অনেক বেশি মেমরি ব্যবহার করে (প্রতিটি নোডে দুটি অতিরিক্ত পয়েন্টার থাকে এবং প্রতিটি নোডের সাথে পৃথক অতিরিক্ত ওভারহেড বাইট থাকে যা একটি পৃথক মোড়কের বস্তু হয়)।

— কেভিন ব্রক

এটি এখানে সবচেয়ে দরকারী উত্তর। এটি একটি লজ্জার বিষয় যে এতগুলি প্রোগ্রামার বুঝতে ব্যর্থ হয়েছে (ক) বিমূর্ত তথ্য প্রকার এবং কংক্রিট প্রয়োগের মধ্যে পার্থক্য এবং (খ) পারফরম্যান্স নির্ধারণে ধ্রুবক কারণ এবং মেমরির ওভারহেডের আসল-বিশ্ব গুরুত্ব।

— পোরকুলাস

-1: এটি একটি বরং ঝাপটানো দৃশ্য। হ্যাঁ, এটি সত্য যে অ্যারেলিস্ট একটি অত্যন্ত বহুমুখী সরঞ্জাম। তবে এর সীমাবদ্ধতা রয়েছে। এমন কিছু ক্ষেত্রে রয়েছে যা এটি আপনাকে সমস্যার কারণ হতে পারে এবং আপনাকে লিংকডলিস্টটি ব্যবহার করতে হবে। অবশ্যই, এটি একটি খুব বিশেষ সমাধান, এবং কোনও বিশেষ সরঞ্জাম হিসাবে, বেশিরভাগ ক্ষেত্রেই এটি বহুমুখী একের চেয়ে বেশি কার্যকর হয়। তবে এর অর্থ এই নয় যে এটি "স্তন্যপান" বা এর মতো কিছু, কখন আপনাকে এটি ব্যবহার করতে হবে তা আপনাকে কেবল জানতে হবে।

— ম্যালকম

@ ডেভিডটার্নার: এগুলির উপস্থিতি আছে তবে আমার মনে হয় টমের বক্তব্যটি যদি আপনাকে জিজ্ঞাসা করতে হয় তবে আপনি সম্ভবত অ্যারেলিস্ট চান।

— user541686

Answer 4

যে কেউ প্রায় এক দশক ধরে খুব বড় আকারের এসওএ ওয়েব পরিষেবাদিতে অপারেশনাল পারফরম্যান্স ইঞ্জিনিয়ারিং করে চলেছেন, আমি অ্যারেলিস্টের চেয়ে লিংকডলিস্টের আচরণটি পছন্দ করব। যদিও লিংকডলিস্টের অবিচলিত স্ট্রুটপুট আরও খারাপ এবং তাই আরও হার্ডওয়্যার কেনার কারণ হতে পারে - চাপে থাকা অ্যারেলিস্টের আচরণ অ্যাপ্লিকেশনগুলিকে একটি ক্লাস্টারের নিকটবর্তী সিনক্রোনাইটিতে তাদের অ্যারেগুলি প্রসারিত করতে পারে এবং বড় অ্যারের আকারের জন্য প্রতিক্রিয়াশীলতার অভাব হতে পারে অ্যাপ্লিকেশন এবং একটি আউটজেজে চাপের মধ্যে থাকা, যা বিপর্যয়কর আচরণ।

একইভাবে, আপনি ডিফল্ট থ্রুটপুট ট্যুরড আবর্জনা সংগ্রহকারী থেকে একটি অ্যাপ্লিকেশনটিতে আরও ভাল থ্রুপুট পেতে পারেন তবে আপনি একবার 10 জিবি হ্যাপ সহ জাভা অ্যাপ্লিকেশনগুলি পেয়ে গেলে আপনি পুরো জিসির সময় 25 সেকেন্ডের জন্য অ্যাপটিকে লক আপ করতে পারেন যা এসওএ অ্যাপ্লিকেশনগুলিতে সময়সীমা ও ব্যর্থতার কারণ হয়ে দাঁড়ায় এবং যদি আপনার এসএলএগুলি খুব ঘন ঘন ঘটে তবে এটি ফুটিয়ে তোলে। যদিও সিএমএস সংগ্রাহক আরও সংস্থান গ্রহণ করে এবং একই কাঁচা থ্রুপুট অর্জন না করে, এটি আরও অনেক ভাল পছন্দ কারণ এটির আরও অনুমানযোগ্য এবং আরও কম বিলম্ব রয়েছে।

অ্যারেলিস্ট পারফরম্যান্সের জন্য কেবলমাত্র আরও ভাল পছন্দ যদি আপনি পারফরম্যান্স দ্বারা বোঝানো সমস্ত হ'ল থ্রুপুট এবং আপনি বিলম্বকে উপেক্ষা করতে পারেন। আমার কাজের ক্ষেত্রে আমার অভিজ্ঞতায় আমি খারাপের ক্ষেত্রে বিলম্বকে উপেক্ষা করতে পারি না।

Comments

অ্যারেলিস্টের নিশ্চিতকরণের ক্ষমতা () পদ্ধতিটি ব্যবহার করে কি আর কোনও সমাধান প্রোগ্রামের মতো তালিকার আকার পরিচালনা করছে না? আমার প্রশ্ন হ'ল এতগুলি জিনিস কেন গুচ্ছ ডেটা স্ট্রাকচারের একটি গোছায় সংরক্ষণ করা হচ্ছে যখন সেগুলি আরও ভালভাবে ক্যাচিং বা ডিবি ব্যবস্থায় সংরক্ষণ করা যেতে পারে? অন্যদিন আমার একটি সাক্ষাত্কার ছিল যেখানে তারা অ্যারেলিস্টের কুফলগুলি সম্পর্কে উচ্চস্বরে শপথ করেছিল, তবে আমি এখানে এসে দেখি যে জটিলতা বিশ্লেষণটি চারদিকে আরও ভাল is বিবেচনার জন্য দুর্দান্ত পয়েন্ট, OU ধন্যবাদ!

— ই

একবার আপনি 10 জিবি হিপ সহ জাভা অ্যাপসটি পেয়ে গেলে আপনি পুরো জিসির সময় 25 সেকেন্ডের জন্য অ্যাপ্লিকেশনটি লকআপ বন্ধ করতে পারেন যা লিংকডলিস্টের সাহায্যে আপনি পুরো জিসিগুলিতে আবর্জনা সংগ্রাহককে খুন করেন, এটি ক্যাশে মিস সহ অতিমাত্রায় বৃহত লিংকডলিস্টটি পুনরাবৃত্তি করতে হবে প্রতিটি নোড

— বেটসেস

এটি ... একটি ভয়াবহ সমাধান। আপনি মূলত আপনার জন্য জিসি পরিষ্কার করার উপর নির্ভরশীল, যা অবিশ্বাস্যরূপে ব্যয়বহুল, যখন আপনি কেবল পরিবর্তে একটি অ্যারেলিস্টে নিশ্চিতকরণের ক্ষমতা () কল করতে পারেন ...

— ফিলিপ ডিভাইন

@ আন্ড্রেয়াস: একটি LinkedList সর্বদা রেফারেন্সের সরল অ্যারের চেয়ে মেমরির পাঁচগুণ বরাদ্দ করে, তাই ArrayListঅস্থায়ীভাবে 2.5 বারের প্রয়োজন হলেও স্মৃতি পুনরুদ্ধার না হওয়া সত্ত্বেও অনেক কম মেমরি গ্রহণ করে। যেহেতু বড় অ্যারের বরাদ্দটি ইডেনের স্থানটিকে বাইপাস করে, জিসি আচরণের উপর তাদের কোনও প্রভাব নেই, যদি না সত্যিকারের পর্যাপ্ত স্মৃতি না থাকে, সেক্ষেত্রে, LinkedListঅনেক আগেই

— হোলার

@ অ্যান্ড্রেয়াস অন্যান্য সমস্যাটি হল কীভাবে স্মৃতি বরাদ্দ করা হয়। LinkedListপরবর্তী উপাদানগুলির জন্য বরাদ্দ করতে কেবল ফ্রি মেমরির একটি ছোট অংশ দরকার। আকার পরিবর্তনকৃত অ্যারে বরাদ্দ করতে স্থানের ArrayListবৃহত এবং অবিচ্ছিন্ন মুক্ত ব্লকের প্রয়োজন হবে । যদি গাদাটি খণ্ডিত হয়ে যায়, তবে জিসি কেবলমাত্র একটি উপযুক্ত মেমরির ব্লক মুক্ত করতে পুরো হিপটিকে পুনরায় অর্ডার করতে পারে।

— পাইওটর কুসিমিরজাইক

Answer 5

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)

অ্যালগরিদম: বড়-ওহ স্বরলিপি

অ্যারেলিস্টগুলি একবারে পড়ার মতো অনেকগুলি বা অ্যাপেন্ডারদের লেখার জন্য ভাল তবে সামনে বা মাঝখানে থেকে অ্যাড / অপসারণ করতে খারাপ।

Comments

ধ্রুবক কারণগুলির কথা চিন্তা না করে আপনি সরাসরি বিগ-ও মানগুলি তুলনা করতে পারবেন না। ছোট তালিকার জন্য (এবং বেশিরভাগ তালিকা ছোট), অ্যারেলিস্টের ও (এন) লিংকডলিস্টের ও (1) এর চেয়ে দ্রুত।

— পোরকুলাস

আমি ছোট তালিকাগুলির পারফরম্যান্সের বিষয়ে চিন্তা করি না এবং আমার কম্পিউটার এটি না করে যদি না এটি কোনওভাবে লুপে ব্যবহৃত হয়।

— মার্টেন বোদেউয়েস

লিংকডলিস্টটি মাঝখানে সত্যিই sertোকাতে পারে না O(1)। সন্নিবেশ পয়েন্টটি খুঁজতে এটি অর্ধেক তালিকার মধ্য দিয়ে যেতে হবে।

— থমাস আহলে

লিঙ্কযুক্ত তালিকা: মাঝের হে (1) )োকান - এটি কি ভুল! আমি জানতে পেরেছি যে লিংকডলিস্ট আকারের 1/10 তম অবস্থানে এমনকি সন্নিবেশ একটি অ্যারেলিস্টের 1/10 তম অবস্থানে কোনও উপাদান সন্নিবেশ করার চেয়ে ধীরে ধীরে। আরও খারাপ: সংগ্রহের সমাপ্তি। অ্যারেলিস্টের শেষ পজিশনে (খুব শেষ নয়) সন্নিবেশ করা লিঙ্কডলিস্টের শেষ পজিশনে (খুব শেষ নয়) দ্রুততর

— কাচানোভ

@ কাচানোভ একটিতে সন্নিবেশ করানো LinkedList হ'ল O(1) যদি আপনার সন্নিবেশকারী অবস্থানে একটি ইটারেটর থাকে , অর্থাত্ ListIterator.addএটি এ এর O(1)জন্য LinkedList।

— কিট আছে - অ্যানি-মৌসে

Answer 6

হ্যাঁ, আমি জানি, এটি একটি প্রাচীন প্রশ্ন, তবে আমি আমার দুটি সেন্ট নিক্ষেপ করব:

লিংকডলিস্ট প্রায় সর্বদা ভুল পছন্দ, কর্মক্ষমতা অনুযায়ী wise কিছু নির্দিষ্ট সুনির্দিষ্ট অ্যালগরিদম রয়েছে যেখানে একটি লিঙ্কযুক্তলিস্টের জন্য বলা হয়েছিল, তবে সেগুলি খুব, খুব বিরল এবং অ্যালগরিদম সাধারণত লিঙ্কডলিস্টের তালিকার মাঝখানে উপাদানগুলি সন্নিবেশ করানো এবং মুছতে সক্ষমতার উপর নির্ভর করে সাধারণত অপেক্ষাকৃত দ্রুত, একবার আপনি সেখানে গিয়েছেন ated একটি তালিকার সাথে।

একটি সাধারণ ব্যবহারের ক্ষেত্রে লিংকডলিস্ট অ্যারেলিস্টকে ছাড়িয়ে যায়: এটি একটি সারি। তবে, যদি আপনার লক্ষ্যটি পারফরম্যান্স হয় তবে লিংকডলিস্টের পরিবর্তে আপনার একটি অ্যারেব্লকিংকিউ ব্যবহার করার বিষয়টিও বিবেচনা করা উচিত (যদি আপনি সময়ের আগে আপনার সারির আকারের উপরের একটি বাউন্ড নির্ধারণ করতে পারেন এবং সমস্ত স্মৃতি সামনে রেখে বরাদ্দ করতে পারেন), বা এই বিজ্ঞপ্তিআরলিস্ট বাস্তবায়ন । (হ্যাঁ, এটি ২০০১ সালের, সুতরাং আপনাকে এটিকে উদার করে তোলা দরকার, তবে সাম্প্রতিক একটি জেভিএম-এ নিবন্ধে উদ্ধৃত বাক্যাংশের সাথে আমি তুলনামূলক পারফরম্যান্স অনুপাত পেয়েছি)

Comments

জাভা 6 থেকে আপনি ব্যবহার করতে পারেন ArrayDeque। docs.oracle.com/javase/6/docs/api/java/util/ArrayDeque.html

— থমাস আহলে

ArrayDequeLinkedListসমস্ত অপারেশন একই প্রান্তে না থাকলে ধীর হয়। স্ট্যাক হিসাবে ব্যবহার করার সময় এটি ঠিক আছে তবে এটি একটি ভাল সারি তৈরি করে না।

— জেরেমি তালিকা 2 এ 12

অসন্তুষ্ট - কমপক্ষে ওডাকল এর বাস্তবায়নের জন্য jdk1.7.0_60 এবং নিম্নলিখিত পরীক্ষায়। আমি একটি পরীক্ষা তৈরি করেছিলাম যেখানে আমি 10 মিলিয়ন বার লুপ করি এবং আমার কাছে 10 মিলিয়ন র্যান্ডম পূর্ণসংখ্যার একটি ডেক রয়েছে। লুপের অভ্যন্তরে আমি একটি উপাদানকে জরিপ করি এবং ধ্রুবক উপাদান সরবরাহ করি। আমার কম্পিউটারে লিঙ্কডলিস্ট অ্যারেডেকের চেয়ে 10 গুণ বেশি ধীর এবং কম স্মৃতি ব্যবহার করে)। কারণটি হ'ল অ্যারেলিস্টের বিপরীতে অ্যারেডেক অ্যারের মাথায় একটি পয়েন্টার রাখে যাতে মাথা অপসারণের সময় এটি সমস্ত উপাদান সরিয়ে নিতে না পারে।

— হেন্নো ভার্মিউলেন

ArrayDequeStackস্ট্যাক হিসাবে ব্যবহৃত হওয়ার চেয়ে দ্রুত এবং কাতার হিসাবে ব্যবহৃত হওয়ার চেয়ে দ্রুততর হতে পারে LinkedList।

— akhil_mittal

লক্ষ্য করুন যে আখিল_মিটালের মন্তব্যটি ArrayDequeডকুমেন্টেশনের একটি উদ্ধৃতি ।

— স্টুয়ার্ট

Answer 7

এটি দক্ষতার প্রশ্ন। LinkedListউপাদান যুক্ত এবং মুছে ফেলার জন্য দ্রুত, তবে একটি নির্দিষ্ট উপাদান অ্যাক্সেস করতে ধীর। ArrayListএকটি নির্দিষ্ট উপাদান অ্যাক্সেসের জন্য দ্রুত তবে উভয় প্রান্তে যোগ করতে ধীর হতে পারে এবং বিশেষ করে মাঝখানে মুছে ফেলতে ধীর হতে পারে।

লিঙ্কযুক্ত তালিকার মতো অ্যারে বনাম অ্যারেলিস্ট বনাম লিংকডলিস্ট বনাম ভেক্টর আরও গভীরতায় চলে ।

Answer 8

সঠিক বা ভুল: দয়া করে স্থানীয়ভাবে পরীক্ষা চালান এবং নিজের জন্য সিদ্ধান্ত নিন!

সম্পাদনা / সরান এর LinkedListচেয়ে দ্রুততর ArrayList।

ArrayListসমর্থিত Array, যার আকার দ্বিগুণ হওয়া দরকার, এটি বৃহত পরিমাণে প্রয়োগের ক্ষেত্রে আরও খারাপ।

নীচে প্রতিটি অপারেশনের ইউনিট পরীক্ষার ফলাফল রয়েছে is সময় ন্যানোসেকেন্ডে দেওয়া হয়।

---

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);
    }
}

Comments

সুনির্দিষ্ট হওয়ার জন্য অ্যারেলিস্টকে দ্বিগুণ করার দরকার নেই। প্রথমে সূত্রগুলি পরীক্ষা করুন।

— ডানুবিয়ান নাবিক

এটি লক্ষ করা উচিত যে আপনার উদাহরণটি ত্রুটিযুক্ত ... আপনি মধ্যবর্তী স্ট্রিং থেকে সরিয়ে ফেলছেন: 18 + [2, 12] বাইটস ("ট্রু0ফালস", "ট্রু 500000false"), গড়ে 25 বাইট, যা উপাদানগুলির আকার মাঝখানে. এটি পরিচিত যে এলিমেন্ট বাইট আকার বৃদ্ধি লিঙ্কযুক্ত তালিকাকে আরও ভাল সম্পাদন করে, তালিকার আকার বাড়ার সাথে সাথে একটি স্বচ্ছ অ্যারে (তালিকা) আরও ভাল করবে। সবচেয়ে গুরুত্বপূর্ণ, আপনি স্ট্রিংগুলিতে .equals () করছেন - যা কোনও সস্তা অপারেশন নয়। আপনি যদি পরিবর্তে পূর্ণসংখ্যা ব্যবহার করেন তবে আমার মনে হয় একটি পার্থক্য হবে।

— সেন্ট্রিল

"... বৃহত্তর ভলিউমের অ্যাপ্লিকেশনে আরও খারাপ ": এটি একটি ভুল বোঝাবুঝি। LinkedListঅনেক বেশি মেমরির ওভারহেড রয়েছে কারণ প্রতিটি উপাদানগুলির জন্য পাঁচটি ক্ষেত্র সহ নোড অবজেক্ট রয়েছে। 20 সিস্টেমে 20 বাইট ওভারহেড করে এমন অনেক সিস্টেমে। জন্য মৌলিক উপাদানগুলির জন্য গড় মেমরির ওভারহেড ArrayListহ'ল দেড় শব্দ, যা 6 বাইট এবং 8 টি বাইটের নিকৃষ্টতম ক্ষেত্রে তৈরি করে।

— Lii

আমি এখানে আপনার মানদণ্ডের একটি আরও ভাল সংস্করণ করেছি , ফলাফল সহ - অ্যারেলিস্টের জন্য অ্যাপেন্ড-অন-এন্ড পারফরম্যান্সটি আপনার জন্য কৃত্রিমভাবে কম, কারণ অ্যাডএল একেবারে প্রাথমিক আকারের স্টোরেজ অ্যারে দিচ্ছে, তাই প্রথম সন্নিবেশ সর্বদা একটি ট্রিগার করে arraycopy। এছাড়াও, এতে তথ্য সংগ্রহের আগে জেআইটি সংকলনের অনুমতি দেওয়ার জন্য ওয়ার্মআপ চক্র অন্তর্ভুক্ত রয়েছে।

— ববএমসিজি

জাভা ৮-এর পর থেকে বিলক, আপনি removeIf(element -> condition)যেখানে এটি ফিট করে এটি ব্যবহার করতে পারেন , এটির ArrayListজন্য লুপিং এবং অপসারণের সাথে তুলনা করার তুলনায় এটি দ্রুততর হতে পারে , কারণ প্রতিটি পৃথক উপাদানগুলির জন্য পুরো অবশিষ্ট স্থানটি স্থানান্তর করার প্রয়োজন হয় না। এটি তাত্ত্বিকভাবে যেমন (ও) (ও) LinkedListহিসাবে একটি নির্দিষ্ট দৃশ্যের উপর নির্ভর করে তার থেকে আরও ভাল বা খারাপ সম্পাদন করে LinkedList, তবে কেবল একটি নোড অপসারণ করতে বেশ কয়েকটি মেমরি অ্যাক্সেসের প্রয়োজন হয়, যা ArrayListউল্লেখযোগ্য সংখ্যক উপাদানকে অপসারণের জন্য প্রয়োজনীয় সংখ্যাকে সহজেই অতিক্রম করতে পারে ।

— হোলার

Answer 9

ArrayListমূলত একটি অ্যারে হয়। LinkedListডাবল লিঙ্কযুক্ত তালিকা হিসাবে প্রয়োগ করা হয়।

getচমত্কার স্পষ্ট। ও (1) এর জন্য ArrayList, কারণ ArrayListসূচক ব্যবহার করে এলোমেলো অ্যাক্সেসের অনুমতি দিন। ও (এন) এর জন্য LinkedList, কারণ এটি প্রথমে সূচি খুঁজে পাওয়া দরকার। দ্রষ্টব্য: বিভিন্ন সংস্করণ আছে addএবং remove।

LinkedListযোগ এবং অপসারণ দ্রুত, কিন্তু পেতে ধীর। সংক্ষেপে, LinkedListঅগ্রাধিকার দেওয়া উচিত যদি:

1. উপাদানের এলোমেলো অ্যাক্সেসের বিশাল সংখ্যা নেই
2. প্রচুর সংখ্যক অ্যাড / রিমুভ অপারেশন রয়েছে

=== অ্যারেলিস্ট ===

• যোগ করুন (ই ই)
  • অ্যারেলিস্টের শেষে যুক্ত করুন
  • মেমরি পুনরায় আকার ব্যয় প্রয়োজন।
  • ও (এন) নিকৃষ্টতম, ও (1) স্বতন্ত্র
• যোগ করুন (ইন্ট ইনডেক্স, ই উপাদান)
  • একটি নির্দিষ্ট সূচক অবস্থান যুক্ত করুন
  • স্থানান্তরকরণ এবং সম্ভাব্য মেমরির পুনরায় আকারের ব্যয় প্রয়োজন
  • চালু)
• অপসারণ (ইনটেক্স ইনডেক্স)
  • একটি নির্দিষ্ট উপাদান অপসারণ
  • স্থানান্তরকরণ এবং সম্ভাব্য মেমরির পুনরায় আকারের ব্যয় প্রয়োজন
  • চালু)
• অপসারণ (অবজেক্ট ও)
  • এই তালিকা থেকে নির্দিষ্ট উপাদানটির প্রথম উপস্থিতি সরিয়ে ফেলুন
  • প্রথমে উপাদানটি অনুসন্ধান করা দরকার এবং তারপরে পরিবর্তন এবং সম্ভাব্য মেমরির পুনরায় আকার দিতে হবে
  • চালু)

=== লিঙ্কডলিস্ট ===

• যোগ করুন (ই ই)

  • তালিকার শেষে যুক্ত করুন
  • হে (1)

• যোগ করুন (ইন্ট ইনডেক্স, ই উপাদান)

  • নির্দিষ্ট অবস্থানে sertোকান
  • প্রথমে পজিশন খুঁজে পাওয়া দরকার
  • চালু)
• অপসারণ()
  • তালিকার প্রথম উপাদানটি সরান
  • হে (1)
• অপসারণ (ইনটেক্স ইনডেক্স)
  • নির্দিষ্ট সূচক সহ উপাদানটি সরান
  • প্রথমে উপাদানটি খুঁজে বের করা দরকার
  • চালু)
• অপসারণ (অবজেক্ট ও)
  • নির্দিষ্ট উপাদানটির প্রথম উপস্থিতিটি সরান
  • প্রথমে উপাদানটি খুঁজে বের করা দরকার
  • চালু)

এখানে প্রোগ্রামক্রিক.কমের একটি চিত্র রয়েছে ( addএবং removeএটি প্রথম ধরণের, অর্থাত্ তালিকার শেষে একটি উপাদান যুক্ত করুন এবং তালিকার নির্দিষ্ট অবস্থানে উপাদানটি সরান)):

Comments

"লিঙ্কডলিস্ট যোগ / অপসারণের চেয়ে দ্রুত" ভুল, উপরে উত্তর চেক stackoverflow.com/a/7507740/638670

— Nerrve

Answer 10

লিংকডলিস্টের লেখক জোশুয়া ব্লচ:

আসলেই কি কেউ লিঙ্কডলিস্ট ব্যবহার করে? আমি এটি লিখেছি, এবং আমি কখনই এটি ব্যবহার করি না।

লিঙ্ক: https://twitter.com/joshbloch/status/583813919019573248

আমি অন্যান্য উত্তরগুলির মতো তথ্যপূর্ণ না হওয়ার জন্য উত্তরটির জন্য দুঃখিত, তবে আমি ভেবেছিলাম এটি সবচেয়ে আকর্ষণীয় এবং স্ব-ব্যাখ্যামূলক হবে।

Answer 11

ArrayListএলোমেলোভাবে অ্যাক্সেসযোগ্য, তবে এর LinkedListথেকে উপাদানগুলি প্রসারিত এবং সরানো সত্যিই সস্তা cheap বেশিরভাগ ক্ষেত্রে,ArrayList ভাল।

যদি আপনি বড় তালিকা তৈরি না করে এবং কোনও বাধা পরিমাপ না করেন, তবে সম্ভবত আপনাকে কখনই পার্থক্য নিয়ে চিন্তা করার দরকার নেই।

Comments

লিঙ্কডলিস্টে উপাদান যুক্ত করা সস্তা নয়। লিঙ্কলিস্টে যুক্ত করার চেয়ে অ্যারেলিস্টে মিলিয়ন উপাদান যুক্ত করা প্রায় সবসময়ই দ্রুত is এবং রিয়েল-ওয়ার্ল্ড কোডের বেশিরভাগ তালিকাগুলি এক মিলিয়ন উপাদানও দীর্ঘ নয়।

— পোরকুলাস

যে কোনও বিন্দুতে, আপনি আপনার লিঙ্কডলিস্টে কোনও আইটেম যুক্ত করার ব্যয়টি জানেন। আপনি যে অ্যারেলিস্টটি করেন না (সাধারণভাবে)। মিলিয়ন আইটেমযুক্ত অ্যারেলিস্টে একটি আইটেম যুক্ত করা খুব দীর্ঘ সময় নিতে পারে - এটি কোনও ও (এন) অপারেশন প্লাসের চেয়ে দ্বিগুণ স্টোরেজ না করে আপনি যদি স্থানটি পূর্বনির্ধারিত না করেন। লিঙ্কডলিস্টে একটি আইটেম যুক্ত করা হ'ল হে (1)। আমার শেষ বক্তব্য দাঁড়িয়েছে।

— ডাস্টিন

অ্যারেলিস্টে একটি আইটেম যুক্ত করা ও (1) হয় এটি 1 মিলিয়ন বা 1 বিলিয়ন নয়। লিঙ্কডলিস্টে কোনও আইটেম যুক্ত করা ও (1)। "যুক্ত করা" মানে শেষের দিকে যোগ করা।

— কাচানোভ

আপনি অবশ্যই বাস্তবায়ন আমার চেয়ে আলাদাভাবে পড়েছেন। আমার অভিজ্ঞতা হিসাবে, 1 বিলিয়ন উপাদান অ্যারের অনুলিপি করাতে 1 মিলিয়ন উপাদান অ্যারের অনুলিপি করা বেশি সময় নেয়।

— ডাস্টিন

@ কচানোভ আপনার অবশ্যই ডাস্টিনকে ভুল বোঝা উচিত। আপনি যদি 1 বিলিয়ন আইটেমের অ্যারে ঘোষণা না করেন তবে অবশেষে আপনার অ্যারের আকার পরিবর্তন করতে হবে এমন পরিস্থিতিতে আপনাকে সমস্ত উপাদানকে একটি নতুন বড় অ্যারেতে অনুলিপি করতে হবে তাই কখনও কখনও আপনি ও (এন) পাবেন তবে কোনও লিঙ্কযুক্ত তালিকার সাথে আপনি সর্বদা থাকবেন ও (1) পান

— স্ট্যান আর।

Answer 12

আধুনিক কম্পিউটার আর্কিটেকচারের কারণে টিএল; ডিআরArrayList প্রায় কোনও সম্ভাব্য ব্যবহারের ক্ষেত্রে উল্লেখযোগ্যভাবে আরও দক্ষ হবে - তাই LinkedListখুব অনন্য এবং চরম ঘটনা বাদে এড়ানো উচিত।

---

তত্ত্বগতভাবে, লিঙ্কডলিস্টের জন্য একটি ও (1) রয়েছে add(E element)

এছাড়াও একটি তালিকার মাঝখানে একটি উপাদান যুক্ত খুব দক্ষ হওয়া উচিত।

অনুশীলনটি একেবারেই আলাদা, কারণ লিংকডলিস্ট একটি ক্যাশে হোস্টেল ডেটা কাঠামো। পারফরম্যান্স পিওভির থেকে - খুব কম কেস রয়েছে যেখানে ক্যাশে-বান্ধবীরLinkedList চেয়ে ভাল পারফরম্যান্স হতে পারে । ArrayList

এখানে এলোমেলো অবস্থানগুলিতে উপাদানগুলি সন্নিবেশ করানোর একটি মানদণ্ডের পরীক্ষার ফলাফল রয়েছে। যেহেতু আপনি দেখতে পারেন -, অ্যারে তালিকা অনেক বেশি দক্ষ যদি যদিও তত্ত্ব তালিকা মাঝখানে প্রতিটি সন্নিবেশ "স্থানান্তর" প্রয়োজন হবে এন অ্যারের পরে উপাদান (নিম্ন মান আরও ভাল হয়):

পরবর্তী প্রজন্মের হার্ডওয়্যারে কাজ করা (বড়, আরও দক্ষ ক্যাশে) - ফলাফল আরও চূড়ান্ত:

লিঙ্কডলিস্ট একই কাজটি সম্পাদন করতে আরও অনেক বেশি সময় নেয়। উত্স উত্স কোড

এই জন্য দুটি প্রধান কারণ আছে:

1. প্রধানত - যে নোডগুলি LinkedListএলোমেলোভাবে স্মৃতি জুড়ে ছড়িয়ে পড়ে। র‌্যাম ("র্যান্ডম অ্যাক্সেস মেমোরি") সত্যিই এলোমেলো নয় এবং মেমরির ব্লকগুলি ক্যাশে আনার দরকার। এই ক্রিয়াকলাপটি সময় নেয় এবং যখন এই জাতীয় ফ্যাচগুলি ঘন ঘন ঘটে - ক্যাশে থাকা মেমরি পৃষ্ঠাগুলি সর্বদা প্রতিস্থাপন করা প্রয়োজন -> ক্যাশে মিস হয় -> ক্যাশে কার্যকর নয়। ArrayListউপাদানগুলি অবিচ্ছিন্ন মেমোরিতে সঞ্চয় করা হয় - যা আধুনিক সিপিইউ আর্কিটেকচারটি অপ্টিমাইজ করছে।

2. মাধ্যমিকের LinkedList পিছনে / ফরোয়ার্ড পয়েন্টার ধরে রাখা প্রয়োজন, যার অর্থ তুলনায় সঞ্চিত মান অনুসারে মেমরির চেয়ে তিনগুণ বেশি ArrayList।

ডায়নামিক্যান্টআরে , বিটিডব্লিউ , একটি কাস্টম অ্যারেলিস্ট বাস্তবায়ন হোল্ডিং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হওয়া উচিত এবং খারাপ বা আরও খারাপের ফলাফলগুলি উপস্থাপন করা উচিত:

দ্রষ্টব্য: এটি সি ++ স্টাড লাইবের একটি মানদণ্ড, তবে আমার পূর্ববর্তী অভিজ্ঞতা দেখিয়েছে যে সি ++ এবং জাভা ফলাফলগুলি খুব একই রকম। সোর্স কোড

ক্রমহীন মেমরির অনুলিপি করা একটি ক্রিয়াকলাপ যা আধুনিক সিপিইউগুলি অনুকূল করে তোলে - তত্ত্ব পরিবর্তন করে এবং বাস্তবে আবার তৈরি করে ArrayList/ Vectorআরও দক্ষ করে তোলে

---

ক্রেডিট: এখানে পোস্ট করা সমস্ত মানদণ্ড কেজেল হেডস্ট্রোমে তৈরি করেছেন । আরও বেশি তথ্য তার ব্লগে পাওয়া যাবে

Comments

আমি কোনও কাতাকে অনন্য বা চরম বলব না! একটি অ্যারেলিস্টের পরিবর্তে একটি লিঙ্কলিস্টে একটি ফিফো ক্যু অনেক সহজভাবে প্রয়োগ করা হয়। এটি আপনার অ্যারেলিস্টে একটি দুঃস্বপ্ন যা আপনাকে নিজের শুরুটি ট্র্যাক করতে হবে, থামাতে হবে এবং আপনার নিজের পুনর্নির্মাণ করতে হবে, আপনি পাশাপাশি একটি অ্যারে ব্যবহার করতে পারেন, তবে একটি লিঙ্কযুক্ত তালিকাটি একটি ফিফো। আমি জাভা বাস্তবায়নের বিষয়ে নিশ্চিত নই, তবে একটি লিঙ্কডলিস্ট উভয় সারি এবং ত্রুটিযুক্ত ক্রিয়াকলাপের জন্য ও (1) করতে পারে (মুছে ফেলার জন্য লেজের উপাদানটির একটি বিশেষ পয়েন্টার প্রয়োজন, যা আমি ধরে নিচ্ছি জাভা আছে কিন্তু আমি ডাবল-চেক করে নি ।)

— বিল কে

Answer 13

যদি আপনার কোড থাকে add(0)এবং remove(0), একটি LinkedListএবং এটি সুন্দর addFirst()এবং removeFirst()পদ্ধতি ব্যবহার করুন। অন্যথায়, ব্যবহার করুন ArrayList।

এবং অবশ্যই, পেয়ারা এর ImmutableList আপনার সেরা বন্ধু।

Comments

ছোট তালিকার জন্য, অ্যারেলিস্ট.এডডি (0) এখনও সর্বদা লিংকডলিস্ট.এডডি ফার্স্ট () এর চেয়ে দ্রুত হতে চলেছে।

— পোরকুলাস

@ পরকুলাস আমি ক্রমাগত এই যুক্তিটি শুনছি যে ছোট তালিকার জন্য অ্যারেলিস্ট.এডডি (0) দ্রুততর হবে, এই ছোটটি কত ছোট? 10 টি উপাদান, 1 মিলিয়ন,?

— garg10may

@ গারগ 10 মাই ছোট 10

— জেসি উইলসন

@ পারকুলাস ছোট মানে অ্যারেলিস্টের অন্তর্নিহিত অভ্যন্তরীণ অ্যারের সর্বাধিক ক্ষমতা থেকে কম।

— জানাক মীনা

Answer 14

আমি জানি এটি একটি পুরানো পোস্ট, তবে আমি সত্যই বিশ্বাস করতে পারি না যে কেউ এই LinkedListপ্রয়োগগুলি উল্লেখ করেনি Deque। Deque(এবং Queue) এর পদ্ধতিগুলি কেবলমাত্র দেখুন ; যদি আপনি ন্যায্য তুলনা করতে চান তবে এর LinkedListবিরুদ্ধে দৌড়ে চেষ্টা করুন ArrayDequeএবং বৈশিষ্ট্যটির জন্য বৈশিষ্ট্যটির তুলনা করুন।

Answer 15

এখানে উভয় বিগ-হে স্বরলিপি হয় ArrayListএবং LinkedListএবং CopyOnWrite-ArrayList:

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)

এগুলির উপর ভিত্তি করে আপনাকে সিদ্ধান্ত নিতে হবে যে কোনটি চয়ন করবেন। :)

Comments

>>>> অ্যারেলিস্ট যুক্ত করুন -> ও (1) <- ট্রু নয়। কিছু ক্ষেত্রে

— অ্যারেলিস্টকে

লিঙ্কযুক্তলিস্ট অপসারণ ও (1) নয়, এর জন্য উপাদানটি সরিয়ে ফেলার জন্য এটি অনুসন্ধান করা দরকার, অতএব সবচেয়ে খারাপ ক্ষেত্রে ও (এন) এবং গড় ও (এন / 2)

— '20:05 এ গার্গ

না হয় LinkedList.add(), যদিও বেশিরভাগ উত্তর এখানে তাই বলে।

— ব্যবহারকারী 207421

Answer 16

প্যারামিটারের নীচে লিংকডলিস্ট এবং অ্যারেলিস্ট আর্টের তুলনা করা যাক:

1. বাস্তবায়ন

ArrayList হ'ল তালিকার ইন্টারফেসের পুনরায় আকার পরিবর্তনযোগ্য অ্যারে বাস্তবায়ন while

লিঙ্কডলিস্ট হ'ল তালিকার ইন্টারফেসের দ্বিগুণ-সংযুক্ত তালিকার প্রয়োগ।

---

2. পারফরম্যান্স

• (ইনটেক্স) বা অনুসন্ধান অপারেশন পান

  ArrayList ( ইনডেক্স) অপারেশন স্থির সময়ে অর্থাৎ ও (1) এর মধ্যে চলে

  লিঙ্কডলিস্ট গেট ( ইনড ইনডেক্স) অপারেশন রান সময় হ'ল ও (এন)।

  পিছনে কারণ ArrayList দ্রুত LinkedList চেয়ে হচ্ছে, যে ArrayList যেমন অভ্যন্তরীণভাবে, একটি বিন্যাস ডাটা স্ট্রাকচার ব্যবহার অন্যদিকে তার উপাদানের জন্য একটি সূচক ভিত্তিক সিস্টেমের ব্যবহার করে

  লিঙ্কডলিস্ট তার উপাদানগুলির জন্য সূচক ভিত্তিক অ্যাক্সেস সরবরাহ করে না কারণ এটি নির্দিষ্ট উপাদান সূচকটিতে নোডটি পুনরুদ্ধার করতে শুরু বা শেষ থেকে (যাহা নিকটবর্তী হয়) পুনরাবৃত্তি করে।

• সন্নিবেশ () বা যোগ (অবজেক্ট) অপারেশন

  লিঙ্কলিস্টে সন্নিবেশ সাধারণত অ্যারেলিস্টের তুলনায় দ্রুত হয়। লিংকডলিস্টে যুক্ত বা সন্নিবেশ হ'ল ও (1) অপারেশন।

  অ্যারেলিস্টে থাকাকালীন , অ্যারেটি যদি পূর্ণরূপে বা খারাপ পরিস্থিতি হয় তবে অ্যারের আকার পরিবর্তন করতে এবং নতুন অ্যারেতে উপাদানগুলি অনুলিপি করতে অতিরিক্ত ব্যয় হয়, যা অ্যারেলিস্ট ও (এন) এ অ্যাড অপারেশন চালনার সময় করে তোলে, অন্যথায় এটি ও (1) ।

• অপসারণ (int) অপারেশন

  লিংকডলিস্টে অপসারণ অপারেশন সাধারণত অ্যারেলিস্ট অর্থাৎ ও (এন) এর সমান।

  ইন LinkedList , দুই ওভারলোড অপসারণ পদ্ধতি। একটি হ'ল অপসারণ () কোনও প্যারামিটার ছাড়াই যা তালিকার মাথাটি সরিয়ে দেয় এবং ধ্রুবক সময় O (1) এ চলে। লিংকডলিস্টে থাকা অন্যান্য ওভারলোডেড অপসারণের পদ্ধতিটি হ'ল (ইনট) বা অপসারণ (অবজেক্ট) যা অবজেক্টটিকে সরিয়ে দেয় বা প্যারামিটার হিসাবে পাস করেছে। অবজেক্টটি না পাওয়া এবং মূল তালিকা থেকে এটিকে লিঙ্কমুক্ত করা পর্যন্ত এই পদ্ধতিটি লিঙ্কডলিস্টটিকে অতিক্রম করে। সুতরাং এই পদ্ধতির রানটাইম হ'ল ও (এন)।

  যখন ArrayList সরান (int- এ) মেথড, নতুন আপডেট অ্যারের পুরানো অ্যারে থেকে উপাদানগুলি অনুলিপি জড়িত অত: পর তার রানটাইম হে (ঢ) হয়।

---

3. বিপরীত Iterator

লিংকডলিস্টটি অবতরণকারী () ব্যবহার করে বিপরীত দিকে পুনরাবৃত্তি করা যেতে পারে

অ্যারেলিস্টে কোন উত্থানদাতা () নেই , সুতরাং বিপরীত দিকে অ্যারেলিস্টে পুনরাবৃত্তি করতে আমাদের নিজস্ব কোড লিখতে হবে।

---

4. প্রাথমিক ক্ষমতা

যদি কনস্ট্রাক্টর ওভারলোড না হয় তবে অ্যারেলিস্ট প্রাথমিক ক্ষমতার একটি খালি তালিকা 10 তৈরি করে

লিংকডলিস্ট কেবল কোনও প্রাথমিক ক্ষমতা ছাড়াই খালি তালিকা তৈরি করে।

---

5. মেমরি ওভারহেড

লিঙ্কলিস্টে মেমরির ওভারহেড তুলনায় আরও বেশি কারণ লিংকডলিস্টে নোডের পরবর্তী এবং পূর্ববর্তী নোডের ঠিকানা বজায় রাখা দরকার। যদিও

ইন ArrayList প্রতিটি সূচক শুধুমাত্র প্রকৃত বস্তু (ডেটা) ঝুলিতে।

---

সূত্র

Answer 17

আমি সেই অপারেশনের সময় জটিলতার উপর ভিত্তি করে আমি একের পর এক ব্যবহার করি যা আমি সেই নির্দিষ্ট তালিকায় করতাম।

|---------------------|---------------------|--------------------|------------|
|      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    |
|--------------------------------------|

Comments

অ্যারেডেক জিনিসগুলি অ্যারেগুলিতে কিছুটা সামঞ্জস্য করে যেহেতু সামনের / পিছন সন্নিবেশ করান / সরান সমস্ত ও (1) লিংকড লিস্টটি এখনও জয়ী হয় (ট্র্যাকিংয়ের সময় আইট্রেটার অপারেশনস) যোগ / সরানো হয়।

— বিল কে

Answer 18

উপরে অন্য ভালো আর্গুমেন্ট ছাড়াও, আপনি কি লক্ষ্য উচিত ArrayListকার্যকরী RandomAccessইন্টারফেস, যখন LinkedListকার্যকরী Queue।

সুতরাং, দক্ষতা এবং আচরণের পার্থক্যের সাথে তারা কোনওভাবে সামান্য ভিন্ন সমস্যার সমাধান করে (তাদের পদ্ধতিগুলির তালিকা দেখুন)।

Answer 19

আপনি তালিকায় আরও কী কী অপারেশন করবেন তা নির্ভর করে।

ArrayListএকটি সূচকযুক্ত মান অ্যাক্সেস করতে দ্রুত। বস্তু সন্নিবেশ করা বা মুছার সময় এটি আরও খারাপ worse

আরও জানতে, যে কোনও নিবন্ধ পড়ুন যা অ্যারে এবং লিঙ্কযুক্ত তালিকার মধ্যে পার্থক্য সম্পর্কে আলোচনা করে।

Comments

আরও পড়বেন না তা জানতে, কেবল কোডটি লিখুন। এবং আপনি খুঁজে পাবেন যে অ্যারেলিস্ট বাস্তবায়ন সন্নিবেশ এবং মোছার লিংকডলিস্টের পরে দ্রুত।

— কাচানোভ

Answer 20

একটি অ্যারে তালিকা মূলত আইটেমগুলি যুক্ত করার পদ্ধতিগুলির সাথে একটি অ্যারে হয় etc. (এবং পরিবর্তে আপনার জেনেরিক তালিকা ব্যবহার করা উচিত)। এটি এমন একটি আইটেমের সংকলন যা সূচকগুলির মাধ্যমে অ্যাক্সেস করা যায় (উদাহরণস্বরূপ [0])। এটি এক আইটেম থেকে অন্য আইটেমের অগ্রগতি বোঝায়।

একটি লিঙ্কযুক্ত তালিকাটি একটি আইটেম থেকে পরের (আইটেম এ -> আইটেম বি) এর অগ্রগতি নির্দিষ্ট করে। আপনি অ্যারের তালিকার সাথে একই প্রভাব পেতে পারেন, তবে একটি লিঙ্কযুক্ত তালিকাকে একেবারে বলা হয়েছে যেটি আগের আইটেমটি অনুসরণ করবে বলে মনে করা হচ্ছে।

Answer 21

দেখুন তালিকা ইমপ্লিমেনটেসন - জাভা টিউটোরিয়াল ।

Comments

হাই @ ছারভে, লিংকটিতে কেবল উত্তরগুলি 6 টি উপভোট পাবেন? দয়া করে এমন কিছু পয়েন্ট যুক্ত করুন যা লিঙ্কটি সমর্থন করতে পারে .আরাকল যদি তাদের লিঙ্কটি পরিবর্তন করে?

Answer 22

একটি লিঙ্কযুক্ত তালিকার একটি গুরুত্বপূর্ণ বৈশিষ্ট্য (যা আমি অন্য উত্তরে পড়িনি) দুটি তালিকার সংক্ষেপণ। সংযুক্ত তালিকার সাথে একটি অ্যারের সাথে এটি ও (এন) (+ কিছু প্রত্যাবর্তনের ওভারহেড) এটি কেবল ও (1) বা ও (2) ;-)

গুরুত্বপূর্ণ : জাভা LinkedListজন্য এটি সত্য নয়! দেখুন জাভাতে লিঙ্কযুক্ত তালিকার জন্য একটি দ্রুত কনক্যাট পদ্ধতি আছে?

Comments

ওটা কেমন? লিঙ্কযুক্ত তালিকার ডেটা স্ট্রাকচারের সাথে এটি সত্য হতে পারে তবে জাভা লিংকলিস্ট অবজেক্ট নয়। আপনি কেবল একটি nextতালিকা থেকে দ্বিতীয় তালিকার প্রথম নোডের দিকে নির্দেশ করতে পারবেন না । একমাত্র উপায় হ'ল ব্যবহার করা addAll()যা উপাদানগুলিকে ধারাবাহিকভাবে যুক্ত করে, যদিও এটি add()প্রতিটি উপাদানকে লুপ করা এবং কল করার চেয়ে ভাল । ও (1) এ এটি দ্রুত করার জন্য আপনার একটি সংমিশ্রণ ক্লাসের প্রয়োজন হবে (যেমন org.apache.commons.collections.collection.Composite Colલેક્શન) তবে এটি কোনও ধরণের তালিকা / সংগ্রহের জন্য কাজ করবে।

— কেভিন ব্রক

হ্যা, সত্য. আমি সেই অনুযায়ী উত্তরটি সম্পাদনা করেছি। কিন্তু 'কিভাবে' LinkedList সঙ্গে এটা করতে এই উত্তর দেখার stackoverflow.com/questions/2494031/...

— Karussell

Answer 23

অ্যারেলিস্ট এবং লিংকডলিস্টের নিজস্ব উপকারিতা এবং কনস রয়েছে।

অ্যারেলিস্ট লিঙ্কডলিস্টের সাথে তুলনা করে সামঞ্জস্যপূর্ণ মেমরি ঠিকানা ব্যবহার করে যা পরবর্তী নোডের দিকে পয়েন্টার ব্যবহার করে। সুতরাং আপনি যখন অ্যারেলিস্টে কোনও উপাদান সন্ধান করতে চান তখন লিংকডলিস্টের সাথে এন পুনরাবৃত্তি করার চেয়ে দ্রুত।

অন্যদিকে, লিংকডলিস্টে সন্নিবেশ এবং মুছে ফেলা অনেক সহজ কারণ আপনাকে কেবলমাত্র পয়েন্টার পরিবর্তন করতে হবে যেখানে একটি অ্যারেলিস্ট কোনও সন্নিবেশ বা মোছার জন্য শিফট অপারেশনকে বোঝায়।

আপনার অ্যাপে যদি ঘন ঘন পুনরুদ্ধার অপারেশন হয় তবে একটি অ্যারেলিস্ট ব্যবহার করুন। আপনার যদি ঘন ঘন সন্নিবেশ এবং মুছে ফেলা থাকে তবে একটি লিঙ্কযুক্ত তালিকা ব্যবহার করুন।

Answer 24

আমি প্রতিক্রিয়াগুলি পড়েছি, তবে একটি দৃশ্যে আমি সর্বদা একটি অ্যারেলিস্টের উপরে লিংকডলিস্ট ব্যবহার করি যা আমি মতামত শুনতে ভাগ করে নিতে চাই:

প্রতিবার আমার কাছে এমন কোনও পদ্ধতি ছিল যা কোনও ডিবি থেকে প্রাপ্ত তথ্যের তালিকা ফিরিয়ে দেয় আমি সর্বদা লিংকডলিস্ট ব্যবহার করি।

আমার যুক্তিটি হ'ল যেহেতু আমি ঠিক কতগুলি ফলাফল পাচ্ছি তা জানা অসম্ভব, স্মৃতির অপচয় হবে না (যেমন অ্যারেলিস্টে উপাদানগুলির সামর্থ্য এবং প্রকৃত সংখ্যার মধ্যে পার্থক্য রয়েছে), এবং চেষ্টা করার কোনও সময় নষ্ট হবে না ক্ষমতা সদৃশ।

যতদূর সম্ভব অ্যারেলিস্ট, আমি সম্মত হই যে কমপক্ষে আপনার প্রাথমিক সক্ষমতা সহ কনস্ট্রাক্টরটি সর্বদা ব্যবহার করা উচিত, যথাসম্ভব অ্যারেগুলির সদৃশতা হ্রাস করতে।

Answer 25

ArrayListএবং LinkedListপ্রয়োগ List interface এবং তাদের পদ্ধতি এবং ফলাফল উভয়ই প্রায় অভিন্ন। তবে তাদের মধ্যে কয়েকটি পার্থক্য রয়েছে যা প্রয়োজনের উপর নির্ভর করে একে অপরের থেকে আরও ভাল করে তোলে।

অ্যারেলিস্ট বনাম লিঙ্কডলিস্ট

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)সেরা ক্ষেত্রে (শেষ উপাদানটি অপসারণ করার সময়)।

উপসংহার: অ্যারেলিস্টের তুলনায় লিংকডলিস্ট উপাদান মুছা দ্রুত হয়।

কারণ: লিংকডলিস্টের প্রতিটি উপাদান দুটি পয়েন্টার (ঠিকানা) বজায় রাখে যা তালিকার উভয় প্রতিবেশী উপাদানকে নির্দেশ করে। সুতরাং অপসারণের জন্য নোডের দুটি প্রতিবেশী নোডের (পয়েন্ট) উপাদানগুলির মধ্যে পয়েন্টার অবস্থান পরিবর্তন করতে হবে যা সরানো হবে। অ্যারেলিস্টে থাকা অবস্থায় সরানো উপাদান দ্বারা তৈরি স্থান পূরণ করার জন্য সমস্ত উপাদানকে স্থানান্তরিত করা দরকার।

3) Inserts Performance: LinkedListঅ্যাড মেথড O(1)পারফরম্যান্স ArrayListদেয় যখন O(n)সবচেয়ে খারাপ ক্ষেত্রে দেয় । অপসারণের জন্য বর্ণিত কারণটি একই রকম।

4) Memory Overhead: ArrayListসূচি এবং উপাদান ডেটা LinkedListবজায় রাখে অন্যদিকে প্রতিবেশী নোডের জন্য উপাদান ডেটা এবং দুটি পয়েন্টার বজায় রাখে

অতএব তুলনামূলকভাবে লিংকডলিস্টে মেমরির খরচ বেশি।

এই শ্রেণীর মধ্যে কয়েকটি মিল রয়েছে যা নিম্নরূপ:

• অ্যারেলিস্ট এবং লিংকডলিস্ট উভয়ই তালিকা ইন্টারফেসের প্রয়োগ।
• তারা উভয় উপাদান সন্নিবেশ ক্রম বজায় রাখে যার অর্থ অ্যারেলিস্ট এবং লিংকডলিস্ট উপাদানগুলি প্রদর্শন করার সময় ফলাফলের সেটটিতে একই ক্রম থাকবে যাতে উপাদানগুলি তালিকায় .োকানো হয়েছিল।
• এই দুটি ক্লাসই অ-সিঙ্ক্রোনাইজড এবং কালেকশন.সিনক্রোনাইজডলিস্ট পদ্ধতিটি ব্যবহার করে স্পষ্টভাবে সিঙ্ক্রোনাইজ করা যায়।
• iteratorএবং listIteratorএই শ্রেণীর দ্বারা ফিরে হয় fail-fast(যদি তালিকা গঠনের দিক ছাড়া যে কোনো সময় রুপান্তরিত করা হয়েছে কোন ভাবেই পর পুনরুক্তিকারীর তৈরি করা হয় iterator’sনিজের অপসারণ বা যোগ পদ্ধতি, পুনরুক্তিকারীর হবে throwএকটি ConcurrentModificationException)।

লিংকডলিস্ট কখন ব্যবহার করবেন এবং অ্যারেলিস্ট কখন ব্যবহার করবেন?

• সন্নিবেশ এবং অপসারণ অপারেশন উপরে বর্ণিত হিসাবে ভাল পারফরম্যান্স দিতে (O(1))মধ্যে LinkedListতুলনায় ArrayList(O(n))।

  তাই যদি অ্যাপ্লিকেশনটিতে ঘন ঘন সংযোজন এবং মোছার প্রয়োজন হয় তবে লিংকডলিস্ট সেরা পছন্দ।

• অনুসন্ধান ( get method) ক্রিয়াকলাপগুলি দ্রুত Arraylist (O(1))তবে চলছে নাLinkedList (O(n))

  সুতরাং যদি কম সংযোজন এবং অপারেশন এবং সন্ধান অপারেশন প্রয়োজনীয়তা অপসারণ করা হয়, অ্যারেলিস্ট আপনার সেরা বাজি হবে।

Answer 26

ArrayList অপারেশন পেতে (ঝ), দ্রুত LinkedList চেয়ে কারণ:
ArrayList: তালিকা ইন্টারফেসের রিসাইজেবল-বিন্যস্ত বাস্তবায়ন
LinkedList: তালিকা এবং Deque ইন্টারফেস দোকর-লিঙ্ক তালিকা বাস্তবায়ন

তালিকাতে সূচকগুলি অপারেশনগুলি সূচনাকালীন সূচনার নিকটবর্তী বা সূচকগুলির কাছাকাছি থেকে শুরু থেকে শেষের দিকে তালিকাকে অতিক্রম করবে।

Answer 27

1) অন্তর্নিহিত তথ্য কাঠামো

অ্যারেলিস্ট এবং লিংকডলিস্টের মধ্যে প্রথম পার্থক্যটি অ্যারেলিস্টকে অ্যারে দ্বারা সমর্থনযুক্ত যখন লিঙ্কডলিস্টকে লিংকডলিস্ট সমর্থন করে L এটি কর্মক্ষমতা আরও পার্থক্য হতে পারে।

2) লিংকডলিস্ট ডেক প্রয়োগ করে

অ্যারেলিস্ট এবং লিংকডলিস্টের মধ্যে আরেকটি পার্থক্য হ'ল তালিকার ইন্টারফেস বাদে লিংকডলিস্ট ডেক ইন্টারফেস প্রয়োগ করে, যা অ্যাড () এবং পোল () এবং অন্যান্য বেশ কয়েকটি ডেক ফাংশনগুলির জন্য প্রথম আউট অপারেশনগুলিতে প্রথম সরবরাহ করে। 3) অ্যারেলিস্টে উপাদান যুক্ত করা অ্যারেলিস্টে উপাদান যুক্ত করা হ'ল ও (1) অপারেশন যদি এটি অ্যারের পুনঃ-আকারকে ট্রিগার না করে, তবে এটি ও (লগ (এন)) হয়ে যায়, অন্যদিকে, কোনও উপাদান যুক্ত করে লিঙ্কডলিস্টটি ও (1) অপারেশন, কারণ এতে কোনও নেভিগেশনের প্রয়োজন হয় না।

4) একটি অবস্থান থেকে একটি উপাদান অপসারণ

নির্দিষ্ট সূচী থেকে কোনও উপাদান সরিয়ে ফেলতে, যেমন মুছে ফেলা (সূচক) কল করে অ্যারেলিস্ট একটি অনুলিপি অপারেশন সম্পাদন করে যা এটি ও (এন) এর নিকটবর্তী করে তোলে যখন লিংকডলিস্টকে সেই বিন্দুতে অতিক্রম করতে হবে যা এটি ও (এন / ২) করে তোলে , কারণ এটি কাছাকাছি ভিত্তিতে উভয় দিক থেকে অতিক্রম করতে পারে।

5) অ্যারেলিস্ট বা লিংকডলিস্টের উপরে আইট্রেট করা

লিঙ্কলিস্ট এবং অ্যারেলিস্ট উভয়ের জন্য ইট্রেশন হল ও (এন) অপারেশন যেখানে n হ'ল উপাদানগুলির একটি সংখ্যা।

6) একটি অবস্থান থেকে উপাদান পুনরুদ্ধার

Get (সূচীকরণ) অপারেশনটি অ্যারেলিস্টে ও (1) এবং লিংকডলিস্টে এর ও (এন / 2) রয়েছে, কারণ এটি প্রবেশের সময় পর্যন্ত এটি অতিক্রম করতে হবে। যদিও, বিগ ও স্বরলিপিতে ও (এন / 2) কেবল ও (এন) কারণ আমরা সেখানে স্থিরদের উপেক্ষা করি।

7) স্মৃতি

লিংকডলিস্ট একটি র‌্যাপার অবজেক্ট, এন্ট্রি ব্যবহার করে, যা ডাটা এবং পরবর্তী এবং পূর্ববর্তী দুটি নোড সংরক্ষণ করার জন্য একটি স্ট্যাটিক নেস্টেড ক্লাস, যখন অ্যারেলিস্ট কেবল অ্যারেতে ডেটা সঞ্চয় করে।

লিঙ্কলিস্টের চেয়ে অ্যারেলিস্টের ক্ষেত্রে অ্যারেলিস্টের ক্ষেত্রে মেমরির প্রয়োজনীয়তা কম মনে হয় কেবলমাত্র অ্যারে পুনরায় আকারের ক্রিয়াকলাপ সম্পাদন করে এমন ক্ষেত্রে যখন এটি একটি অ্যারে থেকে অন্য অ্যারে সামগ্রী অনুলিপি করে।

অ্যারে যদি যথেষ্ট বড় হয় তবে সে সময়ে প্রচুর মেমরি লাগতে পারে এবং আবর্জনা সংগ্রহের সূত্রপাত করতে পারে, যা প্রতিক্রিয়া সময়কে ধীর করতে পারে।

অ্যারেলিস্ট বনাম লিংকডলিস্টের মধ্যে উপরের সমস্ত পার্থক্য থেকে, দেখে মনে হচ্ছে অ্যারেলিস্ট লিংকডলিস্টের চেয়ে প্রায় সব ক্ষেত্রেই ভাল পছন্দ, আপনি যখন অপসারণ (), বা () পাওয়ার চেয়ে ঘন ঘন যুক্ত () অপারেশন করবেন তখন বাদে।

অ্যারেলিস্টের তুলনায় লিঙ্কযুক্ত তালিকাকে সংশোধন করা আরও সহজ, বিশেষত আপনি যদি শুরু বা শেষ থেকে উপাদানগুলি যোগ করতে বা অপসারণ করছেন কারণ লিঙ্কযুক্ত তালিকাগুলি অভ্যন্তরীণভাবে সেই অবস্থানগুলির রেফারেন্স রাখে এবং সেগুলি ও (1) সময়ে অ্যাক্সেসযোগ্য।

অন্য কথায়, আপনি যে উপাদানগুলিকে যুক্ত করতে চান সেখানে পৌঁছানোর জন্য আপনাকে লিঙ্কযুক্ত তালিকার মধ্য দিয়ে যেতে হবে না, সেক্ষেত্রে সংযোজন ও (এন) অপারেশন হয়ে যায়। উদাহরণস্বরূপ, লিঙ্কিত তালিকার মাঝখানে কোনও উপাদান সন্নিবেশ করা বা মোছা।

আমার মতে জাভাতে বেশিরভাগ ব্যবহারিক উদ্দেশ্যে অ্যারলিস্ট ওভার লিংকডলিস্ট ব্যবহার করুন use

Comments

আমি মনে করি এটি এখানে পুরো গ্রুপের সেরা বর্ণিত উত্তর। এটি সঠিক এবং তথ্যবহুল। আমি শেষ লাইনটি পরিবর্তন করার পরামর্শ দেব - শেষে "সারিগুলি বাদে" যুক্ত করুন যা খুব গুরুত্বপূর্ণ কাঠামো যা আসলে কোনও লিঙ্কযুক্ত তালিকার পক্ষে মোটেই অর্থ দেয় না।

— বিল কে

Answer 28

আমি এখানে যে পরীক্ষাগুলি দেখেছি তার মধ্যে একবার কেবল একবার পরীক্ষা চালায়। তবে আমি যা লক্ষ্য করেছি তা হ'ল আপনাকে এই পরীক্ষাগুলি বহুবার চালানো দরকার এবং শেষ পর্যন্ত তাদের সময়গুলি একত্রিত হবে। মূলত জেভিএমকে উষ্ণ করা দরকার। আমার বিশেষ ব্যবহারের ক্ষেত্রে আমার প্রায় 500 আইটেমের বাড়তে পারে এমন তালিকায় আইটেমগুলি যুক্ত / সরানোর প্রয়োজন ছিল। আমার পরীক্ষাগুলি LinkedListদ্রুত চলে এসেছিল, LinkedListপ্রায় ৫০,০০০ এনএস নিয়ে আসে এবং ArrayListপ্রায় 90,000 এনএসে আসে ... দেয় বা নেয়। নীচের কোডটি দেখুন।

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;
}

Answer 29

উভয় সরান () এবং সন্নিবেশ () উভয় অ্যারেলিস্ট এবং লিঙ্কযুক্তলিস্টের জন্য ও (এন) এর রানটাইম দক্ষতা রয়েছে। যাইহোক, লিনিয়ার প্রসেসিং সময়ের পিছনে কারণটি দুটি ভিন্ন কারণ থেকে আসে:

একটি অ্যারেলিস্টে আপনি O (1) এ এলিমেন্টে পৌঁছেছেন, তবে আসলে কিছু অপসারণ বা সন্নিবেশ করাকে ও (এন) করে তোলে কারণ নিম্নলিখিত সমস্ত উপাদান পরিবর্তন করা দরকার।

লিংকডলিস্টে এটি পছন্দসই উপাদানটিতে পৌঁছতে ও (এন) লাগে, কারণ কাঙ্ক্ষিত সূচী না পৌঁছানো পর্যন্ত আমাদের একেবারে শুরুতে শুরু করতে হবে। প্রকৃতপক্ষে অপসারণ বা সন্নিবেশ করা ধ্রুবক, কারণ আমাদের কেবল অপসারণের জন্য 1 রেফারেন্স এবং সন্নিবেশ () এর জন্য 2 রেফারেন্স পরিবর্তন করতে হবে।

দু'জনের মধ্যে কোনটি সন্নিবেশ করা এবং অপসারণের জন্য দ্রুত, এটি কোথায় ঘটে তার উপর নির্ভর করে। আমরা যদি শুরুর কাছাকাছি হয় তবে লিংকডলিস্টটি দ্রুততর হবে, কারণ আমাদের তুলনামূলকভাবে কয়েকটি উপাদান অতিক্রম করতে হবে। যদি আমরা শেষের কাছাকাছি থাকি তবে একটি অ্যারেলিস্ট দ্রুততর হবে, কারণ আমরা ধ্রুবক সময়ে সেখানে পৌঁছে যাই এবং কেবল এটি অনুসরণ করে থাকা কয়েকটি অবশিষ্ট উপাদান পরিবর্তন করতে হয়। মাঝখানে ঠিকঠাকভাবে করা গেলে লিংকডলিস্টটি আরও ত্বরান্বিত হবে কারণ এন উপাদানগুলির মধ্য দিয়ে যাওয়া এন মানগুলির চেয়ে দ্রুততর হয়।

বোনাস: অ্যারেলিস্টের জন্য এই দুটি পদ্ধতি ও (1) বানানোর কোনও উপায় নেই, তবে লিংকডলিস্টে এটি করার একটি উপায় আসলে আছে। ধরা যাক আমরা আমাদের তালিকায় থাকা উপাদানগুলি সরিয়ে এবং entireোকানোর জন্য পুরো তালিকাটি দিয়ে যেতে চাই। সাধারণত, আপনি লিঙ্কডলিস্ট ব্যবহার করে প্রতিটি উপাদানটির শুরু থেকেই শুরু করতে পারেন, আমরা একটি আইট্রেটারের সাথে কাজ করছি বর্তমান উপাদানটি "সংরক্ষণ" করতেও পারি। আইট্রেটারের সাহায্যে, আমরা একটি লিঙ্কলিস্টে কাজ করার সময় অপসারণ () এবং সন্নিবেশ করার জন্য একটি ও (1) দক্ষতা পাই। এটিই কেবলমাত্র পারফরম্যান্সের সুবিধা হিসাবে তৈরি করা যেখানে আমি লিঙ্কলিস্ট সবসময় অ্যারেলিস্টের চেয়ে আরও ভাল of

Answer 30

অ্যারেলিস্ট বিমূর্ত তালিকাটি প্রসারিত করে তালিকা ইন্টারফেস প্রয়োগ করে। অ্যারেলিস্টটি গতিশীল অ্যারে।
এটি বলা যেতে পারে যে এটি মূলত অ্যারেগুলির

অসুবিধাগুলি কাটিয়ে উঠার জন্যই তৈরি করা হয়েছিল ked
পারফরম্যান্স
arraylist.get()হ'ল (1) যেখানে linkedlist.get()ও (এন)
arraylist.add()ও (1) এবং linkedlist.add()0 (1)
arraylist.contains()ও (এন) এবং linkedlist.contains()ও (এন)
arraylist.next()ও (1) এবং linkedlist.next()ও (1)
arraylist.remove()হ'ল (এন) যেখানে linkedlist.remove()O (1)
অ্যারেলিস্টে
iterator.remove()O (n) রয়েছে
তবে লিঙ্কযুক্ত তালিকায়
iterator.remove()O (1)