কেন আমরা একটি লিঙ্কযুক্ত তালিকায় দ্রুত সাজানোর ব্যবহার করি না?


16

দ্রুত সাজানোর অ্যালগরিদমকে নিম্নলিখিত পদক্ষেপগুলিতে ভাগ করা যায়

  1. পাইভট শনাক্ত করুন।

  2. পিভট উপর ভিত্তি করে লিঙ্কযুক্ত তালিকা পার্টিশন।

  3. সংযুক্ত তালিকাকে পুনরাবৃত্তভাবে 2 ভাগে ভাগ করুন।

এখন, আমি যদি সর্বদা পিভট হিসাবে সর্বশেষ উপাদানটি বেছে নিই, তবে পাইভট উপাদানটি (প্রথম পদক্ষেপ) সনাক্তকরণে সময় লাগে ।O(n)

পাইভট উপাদানটি সনাক্ত করার পরে, আমরা সঠিকভাবে পার্টিশন পয়েন্ট (২ য় ধাপ) সনাক্ত করতে এর ডেটা সঞ্চয় করতে এবং অন্যান্য সমস্ত উপাদানের সাথে এটি তুলনা করতে পারি। আমরা পিভট ডেটা সংরক্ষণ করার সাথে সাথে প্রতিটি তুলনা করতে সময় নেবে এবং প্রতিটি স্ব্যাপে ( 1 ) সময় লাগে । সুতরাং সামগ্রিকভাবে এটি n উপাদানগুলির জন্য O ( n ) সময় নেয় ।O(1)O(1)O(n)n

সুতরাং পুনরাবৃত্তি সম্পর্ক হল:

যাযা কোনও লিঙ্কযুক্ত তালিকার সাথে মার্জ সাজানোর সমান।T(n)=2T(n/2)+nO(nlogn)

তাহলে লিঙ্কযুক্ত তালিকার জন্য দ্রুত সাজানোর চেয়ে কেন মার্জ সাজাকে প্রাধান্য দেওয়া হচ্ছে?


প্রথমটির পরিবর্তে
পাইভট

উত্তর:


19

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

এই কারণে, কুইকোর্টটি লিঙ্কযুক্ত তালিকার জন্য প্রাকৃতিক পছন্দ নয় যখন মার্জ সাজানোর ক্ষেত্রে দুর্দান্ত সুবিধা লাগে great

ল্যান্ডউ নোটেশন (কম বা কম, কারণ কুইকসোর্ট এখনও ) সম্মত, তবে ধ্রুবকটি আরও বেশি।O(n2)

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


তবে গড় সময়ের জটিলতা ঠিক তাই? দ্রুত সাজানোর পাশাপাশি সংযুক্ত তালিকার জন্য মার্জ সাজানোর ব্যবহার।
Zephyr

10
@ জাফির, আপনার মনে রাখা দরকার যে জটিলতার স্বরলিপিটি ধ্রুবক উপাদানকে হ্রাস করে। হ্যাঁ, একটি লিঙ্কযুক্ত তালিকায় কুইকোর্ট এবং লিঙ্কযুক্ত তালিকায় সংযুক্তি হ'ল একই জটিলতা শ্রেণি, তবে যে ধ্রুবকগুলি আপনি দেখছেন না তারা একত্রে দ্রুত একত্রীকরণকে দ্রুত তৈরি করে।
চিহ্নিত করুন

@ জাফির মূলত এটি তাত্ত্বিক এবং অভিজ্ঞতামূলক ফলাফলের পার্থক্য। বুদ্ধিমানভাবে, quicksort দ্রুত হয়।
5

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

3
কুইকসোর্ট কখনই স্থানে থাকে না , এটি একটি সাধারণ ভুল ধারণা। এটির জন্য অতিরিক্ত স্থান প্রয়োজন। তদ্ব্যতীত, "এলোমেলো" মেমরি অ্যাক্সেসের ধরণটিও খুব সঠিক নয়: এটি অন্য উত্তরে বর্ণিত হিসাবে, পাইভোটের পছন্দের উপর নির্ভর করে। O(logn)
কনরাড রুডল্ফ

5

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

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

তবে পয়েন্টারগুলির একটি একক element৪ টি উপাদান অ্যারে যুক্ত করা গেলে আপনি সেই অতিরিক্ত পুনরাবৃত্তিটি এড়াতে পারবেন এবং ( 1 ) অতিরিক্ত অতিরিক্ত স্থানের মধ্যে টির বেশি উপাদানের তালিকা বাছাই করতে পারেন ।264হে(1)

head = list.head;
head_array = array of 64 nulls

while head is not null
    current = head;
    head = head.next;
    current.next = null;
    for(i from 0 to 64)
        if head_array[i] is null
            head_array[i] = current;
            break from for loop;
        end if
        current = merge_lists(current, array[i]);
        head_array[i] = null;
     end for
end while

current = null;
for(i from 0 to 64)
    if head_array[i] is not null
        if current is not null
            current = merge_lists(current, head_array[i]);
        else
            current = head_array[i];
        end if
     end if
 end for

 list.head = current;

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


-2

আপনি একত্রীকরণ সাজানোর, পার্টিশন সাজানোর বৃক্ষ সাজানোর লিখতে এবং ফলাফল তুলনা করতে পারবেন
এটা বেশ সহজ লেখ গাছকে কেমন হয় যদি আপনি কিছু অতিরিক্ত স্থান অনুমতি
গাছকে সাজানোর যুক্ত তালিকা প্রতিটি নোডের দুই পয়েন্টার এমনকি যদি আমরা সাজানোর একেলা তালিকা লিঙ্ক থাকতে হবে
লিঙ্ক তালিকায় আমি
Hoare পার্টিশন অদলবদলের পরিবর্তে সন্নিবেশ এবং মুছে ফেলা পছন্দ করি কেবল দ্বিগুণ সংযুক্ত তালিকার জন্য

program untitled;


type TData = longint;
     PNode = ^TNode;
     TNode = record
                data:TData;
                prev:PNode;
                next:PNode;
             end;

procedure ListInit(var head:PNode);
begin
  head := NIL;
end;

function ListIsEmpty(head:PNode):boolean;
begin
  ListIsEmpty := head = NIL;
end;

function ListSearch(var head:PNode;k:TData):PNode;
var x:PNode;
begin
  x := head;
  while (x <> NIL)and(x^.data <> k)do
     x := x^.next;
  ListSearch := x;
end;

procedure ListInsert(var head:PNode;k:TData);
var x:PNode;
begin
  new(x);
  x^.data := k;
  x^.next := head;
  if head <> NIL then
     head^.prev := x;
   head := x;
   x^.prev := NIL;
end;

procedure ListDelete(var head:PNode;k:TData);
var x:PNode;
begin
   x := ListSearch(head,k);
   if x <> NIL then
   begin
     if x^.prev <> NIL then
        x^.prev^.next := x^.next
      else 
        head := x^.next;
     if x^.next <> NIL then
        x^.next^.prev := x^.prev;
     dispose(x);
   end;
end;

procedure ListPrint(head:PNode);
var x:PNode;
    counter:longint;
begin
  x := head;
  counter := 0;
  while x <> NIL do
  begin
    write(x^.data,' -> ');
    x := x^.next;
    counter := counter + 1;
  end;
  writeln('NIL');
  writeln('Liczba elementow listy : ',counter);
end;

procedure BSTinsert(x:PNode;var t:PNode);
begin
  if t = NIL then
    t := x
  else
    if t^.data = x^.data then
            BSTinsert(x,t^.prev)
        else if t^.data < x^.data then
            BSTinsert(x,t^.next)
        else
            BSTinsert(x,t^.prev);
end;

procedure BSTtoDLL(t:PNode;var L:PNode);
begin
   if t <> NIL then
   begin
     BSTtoDLL(t^.next,L);
     ListInsert(L,t^.data);
     BSTtoDLL(t^.prev,L);
   end;
end;

procedure BSTdispose(t:PNode);
begin
   if t <> NIL then
   begin
    BSTdispose(t^.prev);
    BSTdispose(t^.next);
    dispose(t);
   end; 
end;

procedure BSTsort(var L:PNode);
var T,S:PNode;
    x,xs:PNode;
begin
  T := NIL;
  S := NIL;
  x := L;
  while x <> NIL do
  begin
    xs := x^.next;
    x^.prev := NIL;
    x^.next := NIL;
    BSTinsert(x,t);
    x := xs;
  end;
  BSTtoDLL(T,S);
  BSTdispose(T);
  L := S;
end;

var i : byte;
    head:PNode;
    k:TData;
BEGIN
  ListInit(head);
  repeat
     writeln('0. Wyjscie');
     writeln('1. Wstaw element na poczatek listy');
     writeln('2. Usun element listy');
     writeln('3. Posortuj elementy drzewem binarnym');
     writeln('4. Wypisz elementy  listy');
     readln(i);
     case i of
     0:
     begin
       while not ListIsEmpty(head) do
            ListDelete(head,head^.data);
     end;
     1:
     begin
       writeln('Podaj element jaki chcesz wstawic');
       readln(k);
       ListInsert(head,k);
     end;
     2:
     begin
       writeln('Podaj element jaki chcesz usunac');
       readln(k);
       ListDelete(head,k);
     end;
     3:
     begin
       BSTsort(head);
     end;
     4:
     begin
        ListPrint(head);    
     end
     else
        writeln('Brak operacji podaj inny numer');
     end;
  until i = 0;  
END.

এই
কোডটির কিছু উন্নতি দরকার প্রথমত আমাদের অতিরিক্ত সঞ্চয়স্থান পুনরাবৃত্তির প্রয়োজনের মধ্যে সীমাবদ্ধ করা উচিত
তারপরে আমাদের পুনরাবৃত্তি পুনরাবৃত্তির সাথে প্রতিস্থাপনের চেষ্টা করা উচিত
যদি আমরা আরও অ্যালগরিদম আরও উন্নত করতে চাই তবে আমাদের উচিত স্বয়ং ব্যালেন্সিং ট্রি ব্যবহার করা should


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

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

-2

কুইকসোর্ট
সম্ভবত আমি কুইকোর্টের জন্য পদক্ষেপগুলি দেখাব

তালিকায় যদি একাধিক নোড থাকে

  1. পিভট সিলেকশন
  2. তিনটি সাবলিস্টে পার্টিশন তালিকার
    প্রথম সাবলিস্টে পিভট কী-এর চেয়ে কম কীগুলির সাথে নোড রয়েছে
    দ্বিতীয় সাবলিস্টে পিভট কী সমান
    চাবিযুক্ত নোড রয়েছে তৃতীয় সাবলিস্টে পিভট কী-এর চেয়ে বেশি চাবিযুক্ত নোড রয়েছে
  3. সাবলিস্টগুলির জন্য পুনরাবৃত্ত কলগুলি যাতে পিভট নোডের সমান নোড থাকে না
  4. এক বাছাই করা তালিকায় কন্টেনেট সাজানো সাবলিস্টগুলি

বিজ্ঞাপন 1.
যদি আমরা পাইভট দ্রুত চয়ন করতে চাই তবে পছন্দ সীমিত হয়
আমরা হেড নোড বা লেজ নোড বেছে নিতে পারি
আমাদের তালিকার নোডের পয়েন্টার থাকতে হবে যদি আমরা চাই যে আমাদের পাইভটি
দ্রুত অ্যাক্সেসযোগ্য হয় অন্যথায় আমাদের নোডের সন্ধান করতে হবে

বিজ্ঞাপন ২.
আমরা এই পদক্ষেপের জন্য সারি ক্রিয়াকলাপ ব্যবহার করতে পারি
মুষ্টি আমরা মূল লিঙ্কযুক্ত তালিকা থেকে
নোডকে সনাক্ত করব
পাইভট কী এবং এনভ্যু নোডকে সঠিক সাবলিস্টের সাথে তুলনা করে সাবলিস্টগুলি বিদ্যমান নোড থেকে তৈরি করা হয়েছে এবং
নতুন নোডের জন্য মেমরি বরাদ্দ করার দরকার নেই

লেজ নোডের পয়েন্টারটি কার্যকর হবে কারণ
এই পয়েন্টারের উপস্থিতি সহ সারি ক্রিয়াকলাপ এবং কনটেনটেশন দ্রুত চলে


আমি ভীত আমি এই প্রশ্নের উত্তর কীভাবে দেখতে পাচ্ছিলাম না।
জন এল
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.