আমি কখন লিঙ্কযুক্ত তালিকা বনাম একটি তালিকা ব্যবহার করব


391

লিঙ্কযুক্ত তালিকা বনাম তালিকা ব্যবহার করা কখন ভাল ?


3
জাভা কিউ , খুব আলাদা হওয়া উচিত।
নওফাল

1
@ জোনাথন-অ্যালেন, দয়া করে গৃহীত উত্তর পরিবর্তন করার বিষয়ে বিবেচনা করুন। বর্তমানেরটি ভুল এবং অত্যন্ত বিভ্রান্তিকর।
এক্সপ্লেরিয়া

উত্তর:


107

সম্পাদন করা

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

আসল উত্তর ...

আমি আকর্ষণীয় ফলাফল পেয়েছি:

// Temporary class to show the example
class Temp
{
    public decimal A, B, C, D;

    public Temp(decimal a, decimal b, decimal c, decimal d)
    {
        A = a;            B = b;            C = c;            D = d;
    }
}

লিঙ্কযুক্ত তালিকা (3.9 সেকেন্ড)

        LinkedList<Temp> list = new LinkedList<Temp>();

        for (var i = 0; i < 12345678; i++)
        {
            var a = new Temp(i, i, i, i);
            list.AddLast(a);
        }

        decimal sum = 0;
        foreach (var item in list)
            sum += item.A;

তালিকা (২.৪ সেকেন্ড)

        List<Temp> list = new List<Temp>(); // 2.4 seconds

        for (var i = 0; i < 12345678; i++)
        {
            var a = new Temp(i, i, i, i);
            list.Add(a);
        }

        decimal sum = 0;
        foreach (var item in list)
            sum += item.A;

এমনকি যদি আপনি কেবলমাত্র ডেটা অ্যাক্সেস করেন তবে এটি অনেক ধীর হয় !! আমি বলি কখনও লিঙ্কযুক্ত তালিকা ব্যবহার করবেন না।




এখানে অনেকগুলি সন্নিবেশ করানো আরেকটি তুলনা করা হচ্ছে (আমরা তালিকার মাঝখানে একটি আইটেম সন্নিবেশ করার পরিকল্পনা করছি)

লিঙ্কযুক্ত তালিকা (51 সেকেন্ড)

        LinkedList<Temp> list = new LinkedList<Temp>();

        for (var i = 0; i < 123456; i++)
        {
            var a = new Temp(i, i, i, i);

            list.AddLast(a);
            var curNode = list.First;

            for (var k = 0; k < i/2; k++) // In order to insert a node at the middle of the list we need to find it
                curNode = curNode.Next;

            list.AddAfter(curNode, a); // Insert it after
        }

        decimal sum = 0;
        foreach (var item in list)
            sum += item.A;

তালিকা (7.26 সেকেন্ড)

        List<Temp> list = new List<Temp>();

        for (var i = 0; i < 123456; i++)
        {
            var a = new Temp(i, i, i, i);

            list.Insert(i / 2, a);
        }

        decimal sum = 0;
        foreach (var item in list)
            sum += item.A;

লিঙ্কযুক্ত তালিকার যেখানে উল্লেখ করা হবে তার অবস্থানের উল্লেখ রয়েছে (.04 সেকেন্ড)

        list.AddLast(new Temp(1,1,1,1));
        var referenceNode = list.First;

        for (var i = 0; i < 123456; i++)
        {
            var a = new Temp(i, i, i, i);

            list.AddLast(a);
            list.AddBefore(referenceNode, a);
        }

        decimal sum = 0;
        foreach (var item in list)
            sum += item.A;

সুতরাং কেবলমাত্র যদি আপনি বেশ কয়েকটি আইটেম সন্নিবেশ করার পরিকল্পনা করেন এবং আপনারও কোথাও রেফারেন্স থাকে যেখানে আপনি আইটেমটি সন্নিবেশ করানোর পরিকল্পনা করছেন তারপরে একটি লিঙ্কযুক্ত তালিকা ব্যবহার করুন। কেবল আপনাকে প্রচুর আইটেম inোকাতে হবে এটি এটি দ্রুত করে না কারণ আপনি যেখানে সন্নিবেশ করতে চান সেখানে অনুসন্ধান করতে সময় লাগে।


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

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

6
list.AddLast(a);শেষ দুটি লিঙ্কডলিস্টের উদাহরণগুলিতে ইন-লুপটি কেন ? আমি লুপের আগে একবার এটি list.AddLast(new Temp(1,1,1,1));করছি, শেষ লিংকডলিস্টের পরের মতো, তবে এটি (আমার কাছে) দেখে মনে হচ্ছে আপনি নিজের লুপগুলিতে দ্বিগুণ টেম্পের বস্তু যুক্ত করছেন। (এবং আমি যখন কোনও পরীক্ষার অ্যাপ্লিকেশনটি দিয়ে নিজেকে ডাবল-চেক করি , তখন অবশ্যই লিঙ্কডলিস্টে দ্বিগুণ।)
রাফিন

7
আমি এই উত্তরটি অগ্রাহ্য করেছি। 1) আপনার I say never use a linkedList.পরবর্তী পরামর্শটি প্রকাশিত হওয়ায় আপনার সাধারণ পরামর্শ ত্রুটিযুক্ত। আপনি এটি সম্পাদনা করতে চাইতে পারেন। 2) আপনি সময় কি? এক ধাপে পুরোপুরি ইনস্ট্যান্টেশন, সংযোজন এবং গণনা? বেশিরভাগ ক্ষেত্রে, ইনস্ট্যান্টেশন এবং গণনা পিপিএল সম্পর্কে চিন্তিত নয়, সেগুলি এক সময়ের পদক্ষেপ। বিশেষত সন্নিবেশ এবং সংযোজনগুলির সময় নির্ধারণ করা আরও ভাল ধারণা দেবে। 3) সর্বাধিক গুরুত্বপূর্ণ, আপনি একটি লিঙ্কলিস্টে প্রয়োজনের চেয়ে বেশি যোগ করছেন। এটি একটি ভুল তুলনা। লিঙ্কলিস্ট সম্পর্কে ভুল ধারণা ছড়িয়ে দেয়।
নওফাল

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

276

বেশিরভাগ ক্ষেত্রে, List<T>আরও দরকারী। LinkedList<T>তালিকার মাঝখানে আইটেমগুলি যুক্ত / অপসারণ করার সময় কম ব্যয় হবে, তবে List<T>কেবলমাত্র শেষে সস্তাভাবে যোগ / অপসারণ করা যাবে তালিকাটির ।

LinkedList<T>কেবলমাত্র সর্বাধিক দক্ষ যদি আপনি সিক্যুয়াল ডেটা অ্যাক্সেস করে থাকেন (তবে সামনে বা পিছনের দিকে) - এলোমেলো অ্যাক্সেস তুলনামূলকভাবে ব্যয়বহুল কারণ এটি প্রতিবার শৃঙ্খলে চলতে হবে (সুতরাং কেন এটির সূচক নেই)। তবে, কারণ কList<T> মূলত কেবল একটি অ্যারে (মোড়কযুক্ত) এলোমেলো অ্যাক্সেস ভাল।

List<T>এছাড়াও সমর্থন পদ্ধতির অনেক প্রস্তাব - Find, ToArrayইত্যাদি; যাইহোক, এগুলি LinkedList<T>এক্সটেনশন পদ্ধতিগুলির মাধ্যমে .NET 3.5 / C # 3.0 এর জন্যও উপলব্ধ - যাতে এটি কোনও কারণের চেয়ে কম হয়।


4
তালিকার <> বনাম লিংকডলিস্ট <> এর একটি সুবিধা যা আমি মাইক্রোপ্রসেসরগুলি মেমরির ক্যাচিং কীভাবে প্রয়োগ করে তা উদ্বেগের কথা ভাবিনি। যদিও আমি এটা সম্পূর্ণভাবে বুঝতে পারছি না, এই ব্লগ প্রবন্ধের লেখক "রেফারেন্স এলাকা", যা একটি অ্যারের ঢোঁড়ন তোলে সম্পর্কে অনেক আলোচনা অনেক দ্রুততর একটি লিঙ্ক তালিকা ঢোঁড়ন চেয়ে অন্তত যুক্ত তালিকা কিছুটা মেমরি বিচ্ছিন্ন হয়ে ছড়িয়ে ছিটিয়ে হয়ে থাকে । kjellkod.wordpress.com/2012/02/25/…
রেনিপেট

@ রেনিপিট তালিকাটি একটি গতিশীল অ্যারে দিয়ে প্রয়োগ করা হয় এবং অ্যারেগুলি মেমরির সংলগ্ন ব্লক।
কেসি

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

এটি কি সম্ভব যে সি এর সমস্ত বাস্তবায়ন, অ্যারে, তালিকা <টি> এবং লিংকডলিস্ট <টি> একটি অতি গুরুত্বপূর্ণ ক্ষেত্রে কিছুটা সাবঅপটিমাল: আপনার একটি খুব বড় তালিকা, অ্যাপেনড (অ্যাডলাস্ট) এবং অনুক্রমিক ট্র্যাভারসাল (এক দিকে) দরকার সম্পূর্ণ জরিমানা: অবিচ্ছিন্ন ব্লকগুলি পাওয়ার জন্য আমি কোনও অ্যারে আকার পরিবর্তন করতে চাই না (এটি কি প্রতিটি অ্যারে, এমনকি 20 গিগাবাইট অ্যারের জন্যও গ্যারান্টিযুক্ত?), এবং আমি আকারটি আগাম জানি না, তবে আমি ব্লক আকারটি আগেই অনুমান করতে পারি, যেমন 100 এমবি প্রতিটি সময় আগে রিজার্ভ। এটি একটি ভাল বাস্তবায়ন হবে। বা অ্যারে / তালিকার অনুরূপ, এবং আমি একটি পয়েন্ট মিস করেছি?
ফিল্ম

1
@ ফিল্ম এটি এমন এক দৃশ্যের যেখানে আপনি আপনার নির্বাচিত ব্লক কৌশলের উপর নিজের শিম লেখেন; List<T>এবং T[]খুব চঞ্চল হওয়ার জন্য ব্যর্থ হবে (সমস্ত এক স্ল্যাব), LinkedList<T>খুব দানাদার হওয়ার জন্য বিলাপ করবে (উপাদান প্রতি স্ল্যাব)।
মার্ক Gravell

212

লিঙ্কযুক্ত তালিকাকে তালিকা হিসাবে ভাবা কিছুটা বিভ্রান্তিকর হতে পারে। এটি আরও একটি চেইনের মতো। প্রকৃতপক্ষে। নেট, LinkedList<T>এমনকি বাস্তবায়ন করে নাIList<T> । কোনও লিঙ্কযুক্ত তালিকায় সূচকের আসল ধারণা নেই, যদিও মনে হয় এটি রয়েছে। অবশ্যই শ্রেণিতে প্রদত্ত কোনও পদ্ধতিই সূচকগুলি গ্রহণ করে না।

লিঙ্কযুক্ত তালিকাগুলি এককভাবে সংযুক্ত, বা দ্বিগুণভাবে লিঙ্কযুক্ত হতে পারে। এটি শৃঙ্খলের প্রতিটি উপাদানগুলির কেবলমাত্র পরবর্তী পরবর্তীগুলির সাথে (এককভাবে সংযুক্ত) বা পূর্ববর্তী / পরবর্তী উভয় উপাদানগুলির (দ্বিগুণ সংযুক্ত) উভয়টির লিঙ্ক রয়েছে কিনা তা বোঝায়। LinkedList<T>দ্বিগুণভাবে লিঙ্কযুক্ত।

অভ্যন্তরীণভাবে, List<T>একটি অ্যারে দ্বারা সমর্থিত। এটি মেমরিতে একটি খুব কমপ্যাক্ট উপস্থাপনা সরবরাহ করে। বিপরীতে, LinkedList<T>ধারাবাহিক উপাদানগুলির মধ্যে দ্বি-নির্দেশমূলক লিঙ্কগুলি সঞ্চয় করতে অতিরিক্ত মেমরি জড়িত। সুতরাং LinkedList<T>সাধারণত উইলের মেমরির পদচিহ্নগুলি এর চেয়ে বড় হবে List<T>(ক্যাভেটের সাথে অ্যাপেন্ড List<T>অপারেশনের সময় কার্যকারিতা উন্নত করতে অব্যবহৃত অভ্যন্তরীণ অ্যারে উপাদান থাকতে পারে))

এগুলির পারফরম্যান্সের বৈশিষ্ট্যও রয়েছে:

পরিশেষে

  • LinkedList<T>.AddLast(item) ধ্রুব সময়
  • List<T>.Add(item) নিয়মিত ধ্রুবক সময়, লিনিয়ার সবচেয়ে খারাপ ক্ষেত্রে

শুরুতে যোগ

  • LinkedList<T>.AddFirst(item) ধ্রুব সময়
  • List<T>.Insert(0, item) রৈখিক সময়

সন্নিবেশ

  • LinkedList<T>.AddBefore(node, item) ধ্রুব সময়
  • LinkedList<T>.AddAfter(node, item) ধ্রুব সময়
  • List<T>.Insert(index, item) রৈখিক সময়

অপসারণ

  • LinkedList<T>.Remove(item) রৈখিক সময়
  • LinkedList<T>.Remove(node) ধ্রুব সময়
  • List<T>.Remove(item) রৈখিক সময়
  • List<T>.RemoveAt(index) রৈখিক সময়

গণনা

  • LinkedList<T>.Count ধ্রুব সময়
  • List<T>.Count ধ্রুব সময়

রয়েছে

  • LinkedList<T>.Contains(item) রৈখিক সময়
  • List<T>.Contains(item) রৈখিক সময়

পরিষ্কার

  • LinkedList<T>.Clear() রৈখিক সময়
  • List<T>.Clear() রৈখিক সময়

আপনি দেখতে পাচ্ছেন যে এগুলি বেশিরভাগ সমতুল্য। অনুশীলনে, এর এপিআইLinkedList<T> করা আরও জটিল এবং এর অভ্যন্তরীণ প্রয়োজনীয়তার বিবরণগুলি আপনার কোডের মধ্যে ছড়িয়ে পড়ে।

তবে, যদি আপনাকে তালিকার মধ্যে থেকে অনেকগুলি সন্নিবেশ / অপসারণের প্রয়োজন হয় তবে এটি স্থির সময় দেয় offers List<T>রৈখিক সময় সরবরাহ করে, তালিকার অতিরিক্ত আইটেমগুলি সন্নিবেশ / অপসারণের পরে প্রায় পরিবর্তন করা উচিত।


2
লিঙ্কলিস্টে গণনা কি ধ্রুব? আমি ভাবলাম যে লিনিয়ার হবে?
আয়ান বলার্ড

10
@ আইইন, গণনা উভয় তালিকা ক্লাসে ক্যাশে করা হয়।
ড্রয় নোকস

3
আপনি লিখেছেন যে "তালিকা <T>। যোগ করুন (আইটেম) লোগারিথমিক সময়", তবে এটি আসলে "কনস্ট্যান্ট" যদি তালিকার ক্ষমতাটি নতুন আইটেম সংরক্ষণ করতে পারে এবং "লিনিয়ার" তালিকায় পর্যাপ্ত স্থান এবং নতুন স্থান না থাকে তবে পুনর্নির্মাণ করা।
এস্ট্রেঞ্জার

@ এস্ট্রেঞ্জার, অবশ্যই আপনি ঠিক বলেছেন উপরের দিক থেকে আমি কী ভাবছিলাম তা নিশ্চিত নন - সম্ভবত যে সূক্ষ্ম স্বাভাবিকের সময়টি লোগারিথমিক, যা তা নয়। প্রকৃতপক্ষে amorised সময় ধ্রুবক। আমি সাধারণ তুলনা করার লক্ষ্যে অপারেশনগুলির সবচেয়ে ভাল / নিকৃষ্ট মামলায় যাইনি। আমি মনে করি অ্যাড অপারেশনটি এই বিশদটি সরবরাহ করার জন্য যথেষ্ট তাৎপর্যপূর্ণ। উত্তরটি সম্পাদনা করবে। ধন্যবাদ।
ড্র নোকস

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

118

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

  • নতুন সদস্যকে নির্দেশ করতে সদস্য আই -1 এ পয়েন্টার আপডেট করুন
  • সদস্যকে নির্দেশ করতে নতুন সদস্যের মধ্যে পয়েন্টার সেট করুন i

একটি লিঙ্কযুক্ত তালিকার অসুবিধাটি এলোমেলো অ্যাক্সেস সম্ভব নয়। কোনও সদস্য অ্যাক্সেসের জন্য কাঙ্ক্ষিত সদস্য না পাওয়া পর্যন্ত তালিকাটি ট্র্যাভার করা দরকার।


6
আমি যুক্ত করব যে লিঙ্কযুক্ত তালিকাগুলি উপরের লিঙ্কডলিস্টনোডের মাধ্যমে উল্লিখিত স্টোর প্রতি আইটেমের ওভারহেড রয়েছে যা পূর্ববর্তী এবং পরবর্তী নোডের উল্লেখ করে। এর পেওফের জন্য অ্যারে ভিত্তিক তালিকার বিপরীতে তালিকাটি সঞ্চয় করার জন্য মেমরির একটি সংলগ্ন ব্লক নয়।
paulecoyote

3
মেমরির একটি সংকীর্ণ ব্লক সাধারণত অনুধাবন করা হয় না?
জোনাথন অ্যালেন

7
হ্যাঁ, এলোমেলো অ্যাক্সেস কর্মক্ষমতা এবং মেমরির ব্যবহারের জন্য একটি সংকীর্ণ ব্লক পছন্দ করা হয় তবে সংগ্রহগুলির জন্য যা নিয়মিত আকার পরিবর্তন করতে হয় যেমন অ্যারের মতো কাঠামোটি সাধারণত একটি নতুন স্থানে অনুলিপি করা প্রয়োজন যখন একটি লিঙ্কযুক্ত তালিকার জন্য কেবল মেমরি পরিচালনা করতে হবে সদ্য sertedোকানো / মুছে ফেলা নোড
jpierson

6
আপনার যদি কখনও খুব বড় অ্যারে বা তালিকার সাথে কাজ করতে হয় (কেবল একটি তালিকা কেবল একটি অ্যারে আবৃত করে) আপনি আপনার মেশিনে প্রচুর পরিমাণে মেমরি উপলব্ধ বলে মনে হলেও আপনি মেমরির সমস্যাগুলিতে চলে যেতে শুরু করবেন। তালিকাটি দ্বিগুণ কৌশল ব্যবহার করে যখন এটি অন্তর্নিহিত অ্যারেতে নতুন স্থান বরাদ্দ করে। সুতরাং পূর্ণ একটি 1000000 এলিমেন্ট অ্যারে 2000000 উপাদান সহ একটি নতুন অ্যারেতে অনুলিপি করা হবে। এই নতুন অ্যারেটি একটি স্বচ্ছ মেমরির স্থানে তৈরি করা দরকার যা এটি ধরে রাখতে যথেষ্ট বড়।
অ্যান্ড্রু

1
আমার একটি সুনির্দিষ্ট কেস ছিল যেখানে আমি যা কিছু করেছি তা যুক্ত করা এবং অপসারণ করা এবং একে একে লুপ করা ... এখানে লিঙ্কযুক্ত তালিকাটি সাধারণ তালিকার চেয়ে অনেক বেশি উন্নত ছিল ..
পিটার ২

26

আমার আগের উত্তরটি যথেষ্ট সঠিক ছিল না। সত্যই এটি ভয়ঙ্কর ছিল: ডি কিন্তু এখন আমি আরও অনেক দরকারী এবং সঠিক উত্তর পোস্ট করতে পারি।


আমি কিছু অতিরিক্ত পরীক্ষাও করেছি। আপনি নীচের লিঙ্কটি দ্বারা এটি উত্সটি খুঁজে পেতে পারেন এবং আপনার নিজের পরিবেশে এটি পুনরায় পরীক্ষা করুন: https://github.com/ukushu/DataStructuresTestsAndOther.git

সংক্ষিপ্ত ফলাফল:

  • অ্যারে ব্যবহার করা প্রয়োজন:

    • তাই প্রায়শই সম্ভব। এটি দ্রুত এবং একই পরিমাণ তথ্যের জন্য সবচেয়ে ক্ষুদ্রতম র‌্যাম পরিসীমা নেয়।
    • আপনি যদি কোষের প্রয়োজনীয় গণনা জানেন
    • যদি অ্যারে <85000 বিতে ডেটা সংরক্ষণ করা হয় (পূর্ণসংখ্যার ডেটার জন্য 85000/32 = 2656 উপাদান)
    • উচ্চ র্যান্ডম অ্যাক্সেস গতি প্রয়োজন হলে
  • তালিকাটি ব্যবহারের প্রয়োজন:

    • তালিকার শেষে কোষগুলি যুক্ত করার প্রয়োজন হলে (প্রায়শই)
    • তালিকার প্রারম্ভিক / মাঝখানে কক্ষগুলি যুক্ত করার প্রয়োজন হলে (বন্ধ নয়)
    • যদি অ্যারে <85000 বিতে ডেটা সংরক্ষণ করা হয় (পূর্ণসংখ্যার ডেটার জন্য 85000/32 = 2656 উপাদান)
    • উচ্চ র্যান্ডম অ্যাক্সেস গতি প্রয়োজন হলে
  • লিঙ্কডলিস্ট ব্যবহার করা প্রয়োজন:

    • তালিকার শুরুতে / মাঝামাঝি / শেষে কক্ষগুলি যুক্ত করার প্রয়োজন হলে (প্রায়শই)
    • প্রয়োজন হলে কেবল ক্রমিক অ্যাক্সেস (এগিয়ে / পিছিয়ে)
    • আপনার যদি বড় আইটেম সংরক্ষণ করতে হয় তবে আইটেমের গণনা কম।
    • লিঙ্কগুলির জন্য অতিরিক্ত মেমরি ব্যবহার করার কারণে এটি প্রচুর পরিমাণে আইটেমের জন্য ব্যবহার না করা ভাল।

আরো বিস্তারিত:

изображения сюда описание изображения জানতে আগ্রহী:

  1. LinkedList<T>অভ্যন্তরীণ .NET- এ কোনও তালিকা নয়। এটি এমনকি বাস্তবায়ন করে না IList<T>। এবং সে কারণেই অনুপস্থিত সূচীগুলি এবং সূচকগুলি সম্পর্কিত পদ্ধতি রয়েছে methods

  2. LinkedList<T>নোড-পয়েন্টার ভিত্তিক সংগ্রহ। .NET এ এটি দ্বিগুণ লিঙ্কযুক্ত বাস্তবায়নে রয়েছে। এর অর্থ পূর্বের / পরবর্তী উপাদানগুলির বর্তমান উপাদানের সাথে লিঙ্ক রয়েছে। এবং ডেটা খণ্ডিত - বিভিন্ন তালিকার অবজেক্টগুলি র‌্যামের বিভিন্ন স্থানে অবস্থিত হতে পারে। এছাড়াও এর LinkedList<T>জন্য List<T>বা অ্যারের চেয়ে বেশি মেমরি ব্যবহৃত হবে ।

  3. List<T>নেট। জাভা এর বিকল্প ArrayList<T>। এর অর্থ এটি অ্যারে র‌্যাপার। সুতরাং এটি মেমরির জন্য ডেটা এক সংলগ্ন ব্লক হিসাবে বরাদ্দ করা হয়। যদি বরাদ্দ করা ডেটার আকার 85000 বাইটের বেশি হয়, তবে এটি বৃহত্তর অবজেক্ট হ্যাপে স্থানান্তরিত হবে। আকারের উপর নির্ভর করে এটি হ্যাপ ফ্র্যাগমেন্টেশন (মেমরি ফাঁসের একটি হালকা ফর্ম) হতে পারে। তবে একই সময়ে যদি আকার <85000 বাইট - এটি মেমরিতে একটি খুব কমপ্যাক্ট এবং দ্রুত অ্যাক্সেসের উপস্থাপনা সরবরাহ করে।

  4. একক সংঘবদ্ধ ব্লকটি এলোমেলো অ্যাক্সেস কর্মক্ষমতা এবং মেমরির ব্যবহারের জন্য পছন্দ করা হয় তবে সংগ্রহগুলির জন্য যা নিয়মিত আকার পরিবর্তন করতে হবে যেমন অ্যারের মতো কাঠামোটি সাধারণত একটি নতুন স্থানে অনুলিপি করা প্রয়োজন যখন একটি লিঙ্কযুক্ত তালিকাকে কেবল সন্নিবেশ করা মেমরি পরিচালনা করতে হবে / মোছা নোড


1
প্রশ্ন: "অ্যারে </>> 85.000 বাইটে সংরক্ষিত ডেটা" দিয়ে আপনি অ্যারে / তালিকার প্রতি ডেটা বলতে চাচ্ছেন এলিমেণ্ট আপনি কি করেন? এটি বোঝা গেল যে আপনি পুরো অ্যারের ডেটাসাইজটি বোঝাতে চেয়েছিলেন ..
ফিল্ম

অ্যারে উপাদানগুলি মেমরিতে ক্রমানুসারে অবস্থিত। সুতরাং অ্যারে প্রতি। আমি টেবিলে ভুল সম্পর্কে জানি, পরে আমি এটি সংশোধন করব :) (আমি আশা করি ....)
অ্যান্ড্রু

তালিকাগুলি সন্নিবেশগুলিতে ধীর হয়ে যাওয়ার সাথে যদি একটি তালিকায় প্রচুর টার্নআরন্ড থাকে (প্রচুর সন্নিবেশ / মোছা) মুছে ফেলা স্থানটি দখল করে রাখা মেমরিটি রাখা হয় এবং যদি তাই হয়, তবে এটি "পুনরায়" সন্নিবেশগুলি কী দ্রুত তৈরি করে?
রব

18

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

মূল পার্থক্যটি আসে পারফরম্যান্সের ক্ষেত্রে। উদাহরণস্বরূপ, আপনি যদি ভারী "INSERT" অপারেশন রয়েছে সেই তালিকাটি যদি প্রয়োগ করে থাকেন তবে লিংকডলিস্টের বাইরে থাকা তালিকা। যেহেতু লিংকডলিস্ট এটি ও (1) সময়ে করতে পারে তবে তালিকাকে অন্তর্নিহিত অ্যারের আকার প্রসারিত করতে হতে পারে। আরও তথ্য / বিশদের জন্য আপনি লিঙ্কডলিস্ট এবং অ্যারের ডেটা স্ট্রাকচারের মধ্যে অ্যালগোরিদমিক পার্থক্যটি পড়তে চাইতে পারেন। http://en.wikedia.org/wiki/Linked_list এবং অ্যারে

আশা করি এই সহায়তা,


4
তালিকা <টি> অ্যারে (টি []) ভিত্তিক, অ্যারেলিস্ট ভিত্তিক নয়। পুনরায় সন্নিবেশ করুন: অ্যারের পুনরায় আকারটি সমস্যাটি নয় (দ্বিগুণকরণ অ্যালগরিদম মানে বেশিরভাগ সময় এটি করতে হবে না): সমস্যাটি হ'ল প্রথমে বিদ্যমান সমস্ত ডেটা ব্লক-অনুলিপি করতে হবে, এতে সামান্য সময় লাগে সময়।
মার্ক গ্র্যাভেল

2
@ মার্ক, 'দ্বিগুণকরণ অ্যালগরিদম "কেবল এটি ও (লগএন) করে তবে এটি ও (1) এর চেয়েও খারাপ
ইলিয়া রাইঝেঙ্কভ

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

@ ইলিয়াআরঝেঙ্কভ - আপনি যে ক্ষেত্রে Addসর্বদা বিদ্যমান অ্যারের শেষে থাকবেন সে বিষয়ে ভাবছেন । Listও (1) না হলেও এটি "যথেষ্ট ভাল"। গুরুতর সমস্যা দেখা দেয় যদি অনেক প্রয়োজন Addগুলি যে না শেষে। মার্ক ইঙ্গিত করছে যে প্রতিবার sertোকালে প্রতিবার বিদ্যমান ডেটা সরিয়ে নেওয়ার প্রয়োজন (কেবলমাত্র আকার পরিবর্তন করার সময় নয়) এর আরও বেশি পারফরম্যান্স ব্যয় । List
টুলমেকারস্টেভ

সমস্যাটি তাত্ত্বিক বিগ হে নোটেশনগুলি পুরো গল্পটি বলে না। কম্পিউটার সায়েন্সে যে কেউ যেহেতু সর্বদা উদ্বিগ্ন, তবে বাস্তব বিশ্বে এর চেয়ে আরও অনেক বেশি বিষয় সম্পর্কে উদ্বিগ্ন হওয়া দরকার।
ম্যাটেট

11

অ্যারেগুলিতে লিঙ্কযুক্ত তালিকার প্রাথমিক সুবিধা হ'ল লিঙ্কগুলি আইটেমগুলিকে দক্ষতার সাথে পুনর্বিন্যাসের সক্ষমতা সরবরাহ করে। সেডজউইক, পি। 91


1
আইএমও এর উত্তর হওয়া উচিত। গ্যারান্টিযুক্ত অর্ডার গুরুত্বপূর্ণ হলে লিংকডলিস্ট ব্যবহার করা হয়।
আরবারদা

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

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

4

লিংকডলিস্ট ব্যবহারের একটি সাধারণ পরিস্থিতি এরকম:

ধরুন আপনি বড় আকারের স্ট্রিংয়ের তালিকা থেকে অনেকগুলি নির্দিষ্ট স্ট্রিং সরিয়ে ফেলতে চান, 100,000 বলুন। মুছে ফেলার স্ট্রিংগুলি হ্যাশসেট ডিকগুলিতে দেখা যাবে এবং বিশ্বাস করা হয় যে স্ট্রিংগুলির তালিকা অপসারণ করতে 30,000 থেকে 60,000 এর মধ্যে স্ট্রিং রয়েছে।

তাহলে 100,000 স্ট্রিংস স্টোর করার জন্য সেরা ধরণের তালিকার কী? উত্তরটি লিংকডলিস্ট। যদি সেগুলি একটি অ্যারেলিস্টে সঞ্চিত থাকে, তবে এটির উপরে পুনরাবৃত্তি হবে এবং মিলিত স্ট্রিংগুলি অপসারণ করতে বিলিয়ন অপারেশন পর্যন্ত নিতে হবে, যখন এটির পুনরুক্তিকারী এবং অপসারণ পদ্ধতি ব্যবহার করে প্রায় 100,000 অপারেশন লাগে।

LinkedList<String> strings = readStrings();
HashSet<String> dic = readDic();
Iterator<String> iterator = strings.iterator();
while (iterator.hasNext()){
    String string = iterator.next();
    if (dic.contains(string))
    iterator.remove();
}

6
আপনি কেবল প্রচুর আইটেম ঘুরে না RemoveAllফেলে আইটেমগুলি সরিয়ে ফেলতে Listবা Whereদ্বিতীয় তালিকা তৈরি করতে লিনকিউ থেকে ব্যবহার করতে পারেন। LinkedListএখানে একটি ব্যবহারের মাধ্যমে অন্য ধরণের সংগ্রহের চেয়ে নাটকীয়ভাবে বেশি মেমরি গ্রাস করা শেষ হয় এবং মেমরির লোকাল হারিয়ে যাওয়ার অর্থ এটি পুনরাবৃত্তিতে উল্লেখযোগ্যভাবে ধীর হবে, এটি এটির চেয়ে বেশ খানিকটা খারাপ করে তোলে List
21:36

@ সার্ভি, নোট করুন যে @ টমের উত্তর জাভা ব্যবহার করে। আমি নিশ্চিত নই যে RemoveAllজাভাতে কোনও সমতুল্য আছে কিনা ।
আর্টুরো টরেস সানচেজ

3
@ আরতুরো টরেস সানচেজ ওয়েল প্রশ্নটি নির্দিষ্ট করে জানিয়েছে যে এটি নেট .NET সম্পর্কে, যাতে কেবল উত্তরটি আরও কম উপযুক্ত করে তোলে।
14

@ সার্ভে, তারপরে আপনার শুরু থেকেই এটি উল্লেখ করা উচিত ছিল।
আর্টুরো টরেস সানচেজ

যদি এর RemoveAllজন্য উপলভ্য না থাকে তবে Listআপনি "সংক্ষেপণ" অ্যালগরিদম করতে পারেন যা টমের লুপের মতো দেখাবে, তবে দুটি সূচক এবং আইটেমগুলি একবারে তালিকার অভ্যন্তরীণ অ্যারেতে রাখার প্রয়োজন সহ। দক্ষতা হ'ল ও (এন), টমের অ্যালগরিদমের মতো LinkedList। উভয় সংস্করণে স্ট্রিংগুলির জন্য হ্যাশসেট কী গণনার সময়। কখন ব্যবহার করবেন এটির একটি ভাল উদাহরণ নয় LinkedList
টুলমেকারস্টেভ

2

আপনার যখন অন্তর্নির্মিত ইনডেক্স অ্যাক্সেস, বাছাইকরণ (এবং এই বাইনারি অনুসন্ধানের পরে) এবং "টোআররে ()" পদ্ধতির দরকার হলে আপনার তালিকা ব্যবহার করা উচিত।


2

মূলত, একটি List<>ইন। নেট একটি অ্যারের উপরে একটি মোড়ক । এ LinkedList<> লিঙ্কযুক্ত তালিকা । সুতরাং প্রশ্নটি নেমে আসে, একটি অ্যারে এবং একটি লিঙ্কযুক্ত তালিকার মধ্যে পার্থক্য কী এবং কোনও লিঙ্কযুক্ত তালিকার পরিবর্তে কখন অ্যারে ব্যবহার করা উচিত। সম্ভবত কোনটি ব্যবহার করবেন সে সম্পর্কে আপনার সিদ্ধান্তের সবচেয়ে গুরুত্বপূর্ণ দুটি কারণগুলি নেমে আসবে:

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

1

এটি টোনো নাম এর গৃহীত উত্তর থেকে এর মধ্যে কয়েকটি ভুল পরিমাপ সংশোধন করে অভিযোজিত ।

পরীক্ষা:

static void Main()
{
    LinkedListPerformance.AddFirst_List(); // 12028 ms
    LinkedListPerformance.AddFirst_LinkedList(); // 33 ms

    LinkedListPerformance.AddLast_List(); // 33 ms
    LinkedListPerformance.AddLast_LinkedList(); // 32 ms

    LinkedListPerformance.Enumerate_List(); // 1.08 ms
    LinkedListPerformance.Enumerate_LinkedList(); // 3.4 ms

    //I tried below as fun exercise - not very meaningful, see code
    //sort of equivalent to insertion when having the reference to middle node

    LinkedListPerformance.AddMiddle_List(); // 5724 ms
    LinkedListPerformance.AddMiddle_LinkedList1(); // 36 ms
    LinkedListPerformance.AddMiddle_LinkedList2(); // 32 ms
    LinkedListPerformance.AddMiddle_LinkedList3(); // 454 ms

    Environment.Exit(-1);
}

এবং কোড:

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace stackoverflow
{
    static class LinkedListPerformance
    {
        class Temp
        {
            public decimal A, B, C, D;

            public Temp(decimal a, decimal b, decimal c, decimal d)
            {
                A = a; B = b; C = c; D = d;
            }
        }



        static readonly int start = 0;
        static readonly int end = 123456;
        static readonly IEnumerable<Temp> query = Enumerable.Range(start, end - start).Select(temp);

        static Temp temp(int i)
        {
            return new Temp(i, i, i, i);
        }

        static void StopAndPrint(this Stopwatch watch)
        {
            watch.Stop();
            Console.WriteLine(watch.Elapsed.TotalMilliseconds);
        }

        public static void AddFirst_List()
        {
            var list = new List<Temp>();
            var watch = Stopwatch.StartNew();

            for (var i = start; i < end; i++)
                list.Insert(0, temp(i));

            watch.StopAndPrint();
        }

        public static void AddFirst_LinkedList()
        {
            var list = new LinkedList<Temp>();
            var watch = Stopwatch.StartNew();

            for (int i = start; i < end; i++)
                list.AddFirst(temp(i));

            watch.StopAndPrint();
        }

        public static void AddLast_List()
        {
            var list = new List<Temp>();
            var watch = Stopwatch.StartNew();

            for (var i = start; i < end; i++)
                list.Add(temp(i));

            watch.StopAndPrint();
        }

        public static void AddLast_LinkedList()
        {
            var list = new LinkedList<Temp>();
            var watch = Stopwatch.StartNew();

            for (int i = start; i < end; i++)
                list.AddLast(temp(i));

            watch.StopAndPrint();
        }

        public static void Enumerate_List()
        {
            var list = new List<Temp>(query);
            var watch = Stopwatch.StartNew();

            foreach (var item in list)
            {

            }

            watch.StopAndPrint();
        }

        public static void Enumerate_LinkedList()
        {
            var list = new LinkedList<Temp>(query);
            var watch = Stopwatch.StartNew();

            foreach (var item in list)
            {

            }

            watch.StopAndPrint();
        }

        //for the fun of it, I tried to time inserting to the middle of 
        //linked list - this is by no means a realistic scenario! or may be 
        //these make sense if you assume you have the reference to middle node

        //insertion to the middle of list
        public static void AddMiddle_List()
        {
            var list = new List<Temp>();
            var watch = Stopwatch.StartNew();

            for (var i = start; i < end; i++)
                list.Insert(list.Count / 2, temp(i));

            watch.StopAndPrint();
        }

        //insertion in linked list in such a fashion that 
        //it has the same effect as inserting into the middle of list
        public static void AddMiddle_LinkedList1()
        {
            var list = new LinkedList<Temp>();
            var watch = Stopwatch.StartNew();

            LinkedListNode<Temp> evenNode = null, oddNode = null;
            for (int i = start; i < end; i++)
            {
                if (list.Count == 0)
                    oddNode = evenNode = list.AddLast(temp(i));
                else
                    if (list.Count % 2 == 1)
                        oddNode = list.AddBefore(evenNode, temp(i));
                    else
                        evenNode = list.AddAfter(oddNode, temp(i));
            }

            watch.StopAndPrint();
        }

        //another hacky way
        public static void AddMiddle_LinkedList2()
        {
            var list = new LinkedList<Temp>();
            var watch = Stopwatch.StartNew();

            for (var i = start + 1; i < end; i += 2)
                list.AddLast(temp(i));
            for (int i = end - 2; i >= 0; i -= 2)
                list.AddLast(temp(i));

            watch.StopAndPrint();
        }

        //OP's original more sensible approach, but I tried to filter out
        //the intermediate iteration cost in finding the middle node.
        public static void AddMiddle_LinkedList3()
        {
            var list = new LinkedList<Temp>();
            var watch = Stopwatch.StartNew();

            for (var i = start; i < end; i++)
            {
                if (list.Count == 0)
                    list.AddLast(temp(i));
                else
                {
                    watch.Stop();
                    var curNode = list.First;
                    for (var j = 0; j < list.Count / 2; j++)
                        curNode = curNode.Next;
                    watch.Start();

                    list.AddBefore(curNode, temp(i));
                }
            }

            watch.StopAndPrint();
        }
    }
}

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


0

LinkedList<>যখন ব্যবহার করুন

  1. আপনি জানেন না যে বন্য গেট দিয়ে কতগুলি জিনিস আসছে। উদাহরণস্বরূপ Token Stream,।
  2. আপনি যখন মুছে ফেলতে চেয়েছিলেন কেবল শেষে the সন্নিবেশ করান।

অন্য কিছুর জন্য, এটি ব্যবহার করা ভাল List<>


6
পয়েন্ট 2 কেন বোঝায় তা আমি দেখতে পাচ্ছি না। লিঙ্কযুক্ত তালিকাগুলি দুর্দান্ত থাকে যখন আপনি পুরো তালিকা জুড়ে অনেকগুলি সন্নিবেশ / মোছা করছেন।
ড্র নোকস

লিঙ্কডলিস্টগুলি ইনডেক্স ভিত্তিক নয় এই কারণে যে আপনাকে ও (এন) জরিমানা দিতে হবে এমন সন্নিবেশ বা মুছে ফেলার জন্য আপনাকে পুরো তালিকাটি স্ক্যান করতে হবে। অন্যদিকে তালিকা <> অ্যারে পুনরায় আকার দেওয়ার ফলে ভোগাচ্ছে তবে লিংকডলিস্টের তুলনায় আইএমও, আরও ভাল বিকল্প better
অ্যান্টনি টমাস

1
আপনি যদি LinkedListNode<T>আপনার কোডের অবজেক্টগুলিকে ট্র্যাক করে রাখেন তবে সন্নিবেশ / মুছার জন্য আপনাকে তালিকাটি স্ক্যান করতে হবে না। যদি আপনি এটি করতে পারেন, তবে এটি ব্যবহারের চেয়ে অনেক বেশি ভাল List<T>, বিশেষত খুব দীর্ঘ তালিকার জন্য যেখানে সন্নিবেশ / অপসারণ ঘন ঘন থাকে।
ড্রয় নোকস

আপনার মানে হ্যাশটেবাল? যদি এটি হয় তবে সমস্যাটি ডোমেনের উপর ভিত্তি করে প্রতিটি কম্পিউটার প্রোগ্রামারকেই একটি পছন্দ করা উচিত সেই নির্দিষ্ট স্থান trade সময়ের ট্রেড অফ :) :) তবে হ্যাঁ, এটি এটি আরও দ্রুত করে তুলবে।
অ্যান্টনি টমাস

1
@ অ্যান্টনি থমাস - না, তার অর্থ উপাদানগুলির রেফারেন্সগুলি ঘুরে দেখার পরিবর্তে নোডের রেফারেন্সগুলি ঘুরে দেখার অর্থ । আপনার সমস্ত কিছু যদি একটি উপাদান হয় তবে তালিকা এবং লিংকডলিস্ট উভয়েরই খারাপ অভিনয় রয়েছে, কারণ আপনাকে অনুসন্ধান করতে হবে। আপনি যদি মনে করেন তবে "তবে তালিকার সাথে আমি কেবল একটি সূচকে পাস করতে পারি": এটি তখনই বৈধ যখন আপনি কখনই তালিকার মাঝখানে কোনও নতুন উপাদান প্রবেশ করান না। লিঙ্কডলিস্টের এই সীমাবদ্ধতা নেই, যদি আপনি কোনও নোড ধরে রাখেন (এবং node.Valueআপনি যখনই মূল উপাদানটি চান তখন ব্যবহার করুন )। সুতরাং আপনি নোডগুলির সাথে কাজ করতে অ্যালগরিদমটি পুনরায় লেখেন, কাঁচা মানগুলি নয়।
নির্মাতা স্টিভ

0

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

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

  1. মনে করুন আপনি উপাদানগুলির মধ্য দিয়ে যাচ্ছেন এবং আপনি প্রচুর পরিমাণে সন্নিবেশ / মুছতে চান; লিংকডলিস্ট এটি লিনিয়ার ও (এন) সময়ে করে, তবে তালিকাটি এটি চতুর্ভুজ O (n ^ 2) সময়ে করে।
  2. মনে করুন আপনি বারবার বড় অবজেক্টগুলিতে অ্যাক্সেস করতে চান, লিংকডলিস্ট খুব বেশি দরকারী হয়ে উঠেছে।
  3. লিংকডলিস্ট ব্যবহার করে ডেক () এবং সারি () আরও ভালভাবে প্রয়োগ করা হয়েছে।
  4. একবার আপনি অনেকগুলি এবং বড় অবজেক্টের সাথে ডিল করার পরে লিংকডলিস্টের আকার বাড়ানো অনেক সহজ এবং ভাল।

আশা করি যে কেউ এই মন্তব্যগুলি দরকারী হবে।


নোট করুন যে এই পরামর্শটি জাভা নয়, নেট। এর জন্য। জাভার লিঙ্কযুক্ত তালিকার বাস্তবায়নে আপনার কাছে "কারেন্ট নোড" ধারণা নেই, সুতরাং আপনাকে প্রতিটি সন্নিবেশের জন্য তালিকাটি অতিক্রম করতে হবে।
জোনাথন অ্যালেন

এই উত্তরটি কেবল আংশিকভাবে সঠিক: ২) উপাদানগুলি বড় হলে উপাদানটিকে স্ট্রাক্ট নয় এমন একটি শ্রেণি তৈরি করুন, যাতে তালিকাটি কেবল একটি রেফারেন্স ধারণ করে। তারপরে উপাদান আকার অপ্রাসঙ্গিক হয়ে যায়। 3) তালিকাতে "সার্কুলার বাফার" হিসাবে ব্যবহার করুন, শুরুতে সন্নিবেশ করানো বা অপসারণের পরিবর্তে ডিক এবং কিউ দক্ষতার সাথে একটি তালিকায় করা যেতে পারে স্টিফেনক্রিয়ারির ডেক । 4) আংশিক সত্য: যখন অনেকগুলি অবজেক্টস, এলএল-এর পক্ষে বিশাল মাপের স্মৃতি প্রয়োজন হয় না; ডাউনসাইড হ'ল নোড পয়েন্টারগুলির জন্য অতিরিক্ত মেমরি।
নির্মাতা স্টিভ

-2

এখানে অনেক গড় উত্তর ...

কিছু লিঙ্কযুক্ত তালিকা বাস্তবায়ন পূর্ব বরাদ্দ নোডের অন্তর্নিহিত ব্লক ব্যবহার করে। যদি তারা ধ্রুবক সময় / লিনিয়ার সময়ের চেয়ে এটি না করে তবে মেমরির কার্য সম্পাদন খারাপ হবে এবং ক্যাশের কার্যকারিতা আরও খারাপ হবে।

লিঙ্কযুক্ত তালিকাগুলি ব্যবহার করুন

1) আপনি থ্রেড সুরক্ষা চান। আপনি আরও ভাল থ্রেড নিরাপদ আলগোস তৈরি করতে পারেন। লকিং ব্যয় একটি সমবর্তী শৈলীর তালিকায় প্রভাব ফেলবে।

2) আপনার যদি স্ট্রাকচারের মতো একটি বৃহত্তর সারি থাকে এবং আপনি মুছে ফেলতে বা যে কোনও জায়গায় যুক্ত করতে চান তবে শেষ সময়টি। > 100 কে তালিকাগুলি বিদ্যমান তবে সাধারণ নয়।


3
এই প্রশ্নটি দুটি সি # বাস্তবায়ন সম্পর্কে ছিল, সাধারণভাবে লিঙ্কযুক্ত তালিকাগুলি নয়।
জনাথন অ্যালেন

প্রতিটি ভাষায় একই
ব্যবহারকারী 1496062

-2

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


1
আপনার বক্তব্য যে পুনরায় Dequeহয় "যুক্ত তালিকা অনুরূপ, কিন্তু উন্নত পারফরম্যান্সের সঙ্গে" । যে বিবৃতি যোগ্যতা অর্জন করুন: Dequeবেশি ভালো কার্য সম্পাদন হয় LinkedList, আপনার নির্দিষ্ট কোডের জন্য । আপনার লিঙ্কটি অনুসরণ করে, আমি দেখতে পাচ্ছি যে দুদিন পরে আপনি ইভান স্টয়েভের কাছ থেকে জানতে পেরেছেন যে এটি লিংকডলিস্টের অদক্ষতা নয়, তবে আপনার কোডের অদক্ষতা। ; (শুধুমাত্র নির্দিষ্ট ক্ষেত্রেই এমনকি যদি এটা LinkedList একজন অদক্ষতা ছিল, যে একটি সাধারণ বিবৃতি যে Deque অধিক দক্ষ হয় ধার্মিক প্রতিপন্ন করবেন না।)
ToolmakerSteve
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.