الگوریتم‌های مرتب‌سازی

از ویکی‌پدیا، دانشنامهٔ آزاد.

الگوریتم مرتب‌سازی، در علوم کامپیوتر و ریاضی، الگوریتمی است که لیستی از داده‌ها را به ترتیبی مشخص می‌‌چیند.

پر استفاده‌ترین ترتیب‌ها، ترتیب‌های عددی و لغت‌نامه‌ای هستند. مرتب‌سازی کارا در بهینه سازی الگوریم‌هایی که به لیست‌های مرتب شده نیاز دارند (مثل جستجو و ترکیب) اهمیت زیادی دارد.

از ابتدای علم کامپیوتر مسائل مرتب‌سازی تحقیقات فراوانی را متوجه خود ساختند، شاید به این علت که در عین ساده بودن، حل آن به صورت کارا پیچیده است. برای مثال مرتب‌سازی حبابی در سال ۱۹۵۶ به وجود آمد. در حالی که بسیاری این را یک مسئلهٔ حل شده می‌‌پندارند، الگوریتم کارآمد جدیدی همچنان ابداع می‌‌شوند (مثلاً مرتب‌سازی کتاب خانه‌ای در سال ۲۰۰۴ مطرح شد).

مبحث مرتب‌سازی در کلاس‌های معرفی علم کامپیوتر بسیار پر کاربرد است، مبحثی که در آن وجود الگوریتم‌های فراوان به آشنایی با ایده‌های کلی و مراحل طراحی الگوریتم‌های مختلف کمک می‌‌کند؛ مانند تحلیل الگوریتم، داده‌ساختارها، الگوریتم‌های تصادفی، تحلیل بدترین و بهترین حالت و حالت میانگین، هزینهٔ زمان و حافظه، و حد پایین.

[ویرایش] طبقه‌بندی

در علم کامپیوتر معمولاً الگوریتم‌های مرتب‌سازی بر اساس این معیارها طبقه‌بندی می‌‌شوند:

  • پیچیدگی (بدترین و بهترین عملکرد و عملکرد میانگین): با توجه به اندازهٔ لیست (n). در مرتب‌سازی‌های معمولی عملکرد خوب (O(n log n و عملکرد بد (O(n2 است. بهترین عملکرد برای مرتب‌سازی (O(n است. الگوریتم‌هایی که فقط از مقایسهٔ کلیدها استفاده می‌کنند در حالت میانگین حداقل (O(n log n مقایسه نیاز دارند.
  • حافظه (و سایر منابع کامپیوتر) : بعضی از الگوریتم‌های مرتب‌سازی "در جا[1]" هستند. یعنی به جز داده‌هایی که باید مرتب شوند، حافظهٔ کمی ((O(1) مورد نیاز است؛ در حالی که سایر الگوریتم‌ها به ایجاد مکان‌های کمکی در حافظه برای نگه‌داری اطلاعات موقت نیاز دارند.
  • پایداری[2] : الگوریتم‌های مرتب‌سازی پایدار ترتیب را بین داده‌های دارای کلیدهای برابر حفظ می‌کنند. فرض کنید می‌خواهیم چند نفر را بر اساس سن با یک الگوریتم پایدار مرتب کنیم. اگر دو نفر با نام‌های الف و ب هم‌سن باشند و در لیست اولیه الف جلوتر از ب آمده باشد، در لیست مرتب شده هم الف جلوتر از ب است.
  • مقایسه‌ای بودن یا نبودن. در یک مرتب‌سازی مقایسه‌ای داده‌ها فقط با مقایسه به وسیلهٔ یک عملگر مقایسه مرتب می‌شوند.
  • روش کلی : درجی، جابجایی، گزینشی، ترکیبی و غیره. جابجایی مانند مرتب‌سازی حبابی و مرتب‌سازی سریع و گزینشی مانند مرتب‌سازی پشته‌ای.

الگوریتم های مرتب سازی 1 - مرتب سازی حبابی (Bubble Sort)

فرض کنید n داده داریم که می خواهیم به صورت صعودی مرتب شوند. عنصر اول رو با دومی مقایسه ، و در صورتی که اولی بزرگتر باشد جاهاشون رو عوض می کنیم. همین کار رو با عناصر دوم و سوم انجام می دهید و همینطور عناصر سوم و چهارم ، الی آخر. وقتی این کار تموم شد بزرگترین عنصر بین داده ها به آخر لیست می رسد . حالا یک بار دیگه از اول این کار رو انجام می دهیم اما این بار تا عنصر (n -1)ام ادامه می دهیم (عنصر nام مرحله اول جای خودش رو پیدا کرده). باز هم این کار رو تا عنصر (n - 2)ام تکرار می کنیم ، و بازهم .... تا اینکه بالاخره داده ها مرتب می شوند. مثلا:

0 - 0 ) 5 6 4 2

1 - 1 ) 5 6 4 2

1 - 2 ) 5 4 6 2

1 - 3 ) 5 4 2 6

2 - 1 ) 4 5 2 6

2 - 2 ) 4 2 5 6

3 - 1 ) 2 4 5 6

مرحله اول سه مقایسه ، مرحله دوم دو مقایسه و مرحله سوم یک مقایسه داره ، که روی هم می شوند شش مقایسه. در کل این روش n (n - 1) / 2 مقایسه لازم داره. اما نه همیشه. به مثال زیر توجه کنید:

0 - 0 ) 0 7 1 3 5 4

1 - 1 ) 0 1 7 3 5 4

1 - 2 ) 0 1 7 3 5 4

1 - 3 ) 0 1 3 7 5 4

1 - 4 ) 0 1 3 5 7 4

1 - 5 ) 0 1 3 5 4 7

2 - 1 ) 0 1 3 5 4 7

2 - 2 ) 0 1 3 5 4 7

2 - 3 ) 0 1 3 5 4 7

2 - 4 ) 0 1 3 4 5 7

3 - 1 ) 0 1 3 4 5 7

3 - 2 ) 0 1 3 4 5 7

3 - 3 ) 0 1 3 4 5 7

4 - 1 ) 0 1 3 4 5 7

4 - 2 ) 0 1 3 4 5 7

5 - 1 ) 0 1 3 4 5 7 همونطور که می بینید انتهای مرحله 2 داده ها مرتب هستن. تشخیص این مساله هم کار سختی نیست: اگه به مرحله ای رسیدیم که هیچ جابجایی در اون رخ نداد نتیجه می شه که داده ها مرتب هستن (مرحله سوم). پس بعد از مرحله 3 مطمئن می شیم که داده هامون مرتب شدن و نیازی به مراحل 4 و 5 نیست. پیاده سازی (مرتب سازی حبابی) در c++


void bubble_sort ( int arr [ ] , int n)

{

 register int i , j , t , c;

(-- for ( i = n - 2 ; i >= 0 ; i

 {
   c = 0;
  (++ for ( j = 0 ; j <= i ; j 
      if ( arr [ j ] > arr [ j + 1 ]) 
    {
    ; ] t = arr [ j
         arr [ j ] = arr [ j + 1 ]; 
      ; arr [ j + 1 ] = t
       C++;
  }
    ( if ( c == 0 
      ; break
 }

}

2 - مرتب سازی انتخابی(Selection Sort)

معمولا اطلاعات و داده های خامی که در اختیار برنامه نویس قرار داره بصورت نامرتب هستن. مواقعی پیش می یاد که لازمه این داده ها بر حسب فیلد خاصی مرتب بشن؛ مثل لیست دانش آموزان بر حسب معدل ، لیست کارمندان بر حسب شماره پرسنلی ، لیست دفترچه تلفن بر حسب نام خانوادگی و ... روشهای متعددی برای مرتب سازی وجود داره که من قصد دارم تا حد امکان شما رو با این روشها آشنا کنم. برای شروع روش مرتب سازی انتخابی (Selection Sort) رو توضیح می دم.

روش انتخابی اولین روشیه که به ذهن می رسه: بزرگترین رکورد بین رکوردهای لیست رو پیدا می کنیم و به انتهای لیست انتقال می دیم. از بقیه رکوردها بزرگترین رو انتخاب می کنیم و انتهای لیست - کنار رکورد قبلی - قرار می دیم و ... مثلا:

0: 9 1 6 4 7 3 5

1: 5 1 6 4 7 3 9

2: 5 1 6 4 3 7 9

3: 5 1 3 4 6 7 9

4: 4 1 3 5 6 7 9

5: 3 1 4 5 6 7 9

6: 1 3 4 5 6 7 9

پیاده سازی (مرتب سازی انتخابی) در c++

void selection_sort ( int arr[] , int n)

{

 register int i , j; 
 int max , temp; 
 (--for ( i = n - 1 ; i > 0 ; i 
 }
   max = 0; 
   for ( j = 1 ; j <= i ; j++) 
     if ( arr[ max ] < arr[ j]) 
           max = j; 
         ; ] temp = arr[ i
           arr[ i ] = arr[ max];
           arr[ max ] = temp;
}

}

3 - مرتب سازی (Shell Sort)

نام این الگوریتم از نام مخترع آن گرفته شده است. در این الگوریتم از روش درج استفاده می شود .

به عنوان مثال رشته f d a c b e را تحت این الگوریتم مرتب می کنیم.

          F     d   a    c    b    e             : شروع
          C     d   a    f    d    e            : مرحله اول
          A     b   c    d    e    f            : مرحله دوم
          A     b   c    d    e    f             : نتیجه
در مرحله اول : دادههای با فاصله 3 از یکدیگر ، مقایسه و مرتب شده ، در مرحله دوم داده های با فاصله 2 از یکدیگر ، مقایسه و مرتب می شوند  و در مرحله دوم داده ها با فاصله یک از یکدیگر مقایسه و مرتب می شوند .

منظور از فاصله سه این است که عنصر اول با عنصر چهارم(3+1) ، عنصر دوم با عنصر پنجم(5=3+2) و عنصر سوم با عنصر ششم(6=3+3) مقایسه شده در جای مناسب خود قرار می گیرد .

برای انتخاب فاصله در اولین مرحله ، تعداد عناصر لیست بر 2 تقسیم می شود(n/2) وفاصله بعدی نیز با تقسیم فاصله فعلی بر 2 حاصل می گردد و الگریتم تا زمانی ادامه پیدا می کند که این فاصله به صفر برسد.

به عنوان مثال)
اگر تعداد عناصر برابر با 10 باشد ، فاصله در مرحله اول برابر با 5 ، در مرحله دوم برابر با 2 ور در مرحله سوم برابر با 1 و در نهایت برابر با صفر خواهد بود .
زمان مرتب سازی shell  از رابطه n       پیروی می کند که نسبت به    n^2  بهبود خوبی پیدا کرده است لذا  سرعت عمل روش مرتب سازی shell   از روشهای  انتخابی ، در جی و حبابی   بیشتر است.

پیاده سازی مرتب سازی Shell sort) ) در c++

  1. include<stdio.h>
  1. include<conio.h>

< include<string.h#

Void shell( int *,char*,int) Int main()

{

           Char s[80];
           Int gap[80];
          (); Clrscr
          ;(": Printf(" Enter a string
          ); Gets(s
          )); Shell(gap,s,strlen(s
          ); Printf(" \n the sorted string is : %s",s
           Getch();
           Return 0;

}

                                                        • //

Void shell(int gap [], char * item, int count) {

               Register int I, j,step,k,p;
              ; Char x
               Gap[0] =count /2;
               While(gap[k] > 1)

{

++; K

Gap[k]=gap[k-1]/2;

}//end of while

For (i= 0;i<=k;i++)

{

Step=gap[i];

For(j=step;j<count; j++)

{

X=item[j];

P=j-step;

            While(p>=0 &&  x<item[p])

{

Item[p+step]=item[p];

P=p-step;

}

Item[p+step]=x;

      }

}

                                              }

4 - مرتب سازی سریع! (Quick Sort)

مرتب سازی سریع (Quick Sort) از جمله روشهای محبوب و با سرعت بالا برای مرتب کردن داده ها محسوب می شه. این روش هم مثل روش ادغام از تقسیم و حل (Divide and Conqure) برای مرتب کردن داده ها استفاده می کنه. به این ترتیب که داده ها رو به دو قسمت مجزا تقسیم، و با مرتب کردن اونها کل داده ها رو مرتب می کنه. برای اینکار یکی از داده ها (مثلا داده اول) به عنوان محور انتخاب می شه. داده ها بر اساس محور طوری چینش می شن که همه داده های کوچکتر از محور سمت چپ و داده های بزرگتر یا مساوی اون سمت راستش قرار می گیرن. با مرتب کردن دو قسمت به دست اومده کل داده ها مرتب می شن. در این حالت مثل روش ادغام نیازی به ادغام کردن داده ها نیست. چرا که قسمت سمت راست همگی از قسمت سمت چپ کوچکتر هستن و بالعکس. مثلا اعداد صحیح زیر رو در نظر بگیرید:

5 6 1 9 -2 4 5 15 3 1 4 10

عدد 5 رو به عنوان محور در نظر می گیریم. داده ها به این صورت بازچینی می شن:

1 -2 4 3 1 4 5 6 9 5 15 10

همونطور که مشاهده می کنید اعداد سمت چپ عدد 5 زیر خط دار همگی از ۵ کوچیکتر و اعداد سمت راست بزرگتر یا مساوی اون هستن.

پیاده سازی مرتب سازی Quick sort) ) در c++

تابع partition با دریافت آرایه و حد بالا و پایین تکه ای که باید تقسیم بشه عملیات لازم رو انجام می ده، و اندیس محل تفکیک رو (محل عدد ۵ در مثال بالا) به عنوان نتیجه بر می گردونه. int partition ( int arr[ ] , int low , int high)

{

int lb = low + 1 , rb = high , temp , pivot = arr[ low ] , p; 
while ( lb <= rb)
{
 while ( arr[ lb ] <= pivot && lb <= rb) 
  lb++; 
 while ( arr[ rb ] > pivot && lb <= rb) 
  rb--; 
 if ( lb < rb) 
 {
  temp = arr[ lb];
  arr[ lb ] = arr[ rb];
  arr[ rb ] = temp;
 }
}
(if ( rb == high
 p = high; 

else if( rb == low)

 p = low; 
else
 p = lb – 1;
arr[ low ] = arr[ p];
arr[ p ] = pivot;
return p;

} اگه این تابع رو برای مثال بالا استفاده کنیم مقدار ۶ (اندیس ۵ زیرخط دار) برگشت داده می شه. با تکرار کردن این عملیات برای دو قسمت به دست اومده (در مثال بالا از اندیس صفر تا ۵ و از اندیس ۷ تا ۱۱) داده ها به صورت کامل مرتب می شن.

بر اساس گفته های بالا تابع مرتب سازی به این صورت خواهد بود: void quick_sort ( int arr[ ] , int low , int high)

{ if ( low < high)

{
 int p = partition( arr , low , high); 
 quick_sort( arr , low , p – 1); 
 quick_sort( arr , p + 1 , high);
}

} همونطور که مشاهده می کنید این تابع بصورت بازگشتی نوشته شده. در صورتی که بخواید به صورت غیر بازگشتی بنویسید باید از پشته به صورت زیر استفاده کنید: void quick_sort ( int arr[ ] ,int n)

{

stack st;
st.push( 0); 
st.push( n – 1); 
int low , p , high; 
while( ! st.isempty())
{
 high = st.pop();
 low = st.pop();
 p = partition( arr , low , high); 
 if ( p > low)
 {
  st.push( low);
  st.push( p – 1); 
 }
 if ( p < high)
{
  st.push( p + 1);
  st.push( high);
 }

}

}

5 - مرتب سازی ادغامSort) Merge)

روش مرتب سازی ادغام از الگوریتم تقسیم و حل (divide-and-conqure) برای مرتب کردن داده ها استفاده می کنه. در این الگوریتم مساله به چند جزء کوچکتر تقسیم می شه. هر کدوم از این قسمتها رو به طور مجزا حل کرده ، و با ترکیب اونها به مساله اصلی می رسیم. و اما طرح کلی مرتب سازی ادغام:

در این روش داده ها به دو قسمت مساوی تقسیم می شن. و هر کدوم از این قسمتها - به صورت بازگشتی - مرتب ، و با ادغامشون دادها بصورت کامل مرتب می شن.

پیاده سازی مرتب سازی Merge sort) ) در c++

void merge_sort ( int arr[ ] , int low , int high)

{

if ( low >= high) 
 return;
int mid = ( low + high ) / 2; 
merge_sort ( arr , low , mid);
merge_sort ( arr , mid + 1 , high); 
merge_array ( arr , low , mid , high); 

} procedure merge_sort ( var arr : array of integer ; l : integer ; h : integer); var

m : integer;

begin

if l >= h then
 exit;
m := ( l + h ) div 2; 
merge_sort ( arr , l , m);
merge_sort ( arr , m + 1 , h);
merge_array ( arr , l , m , h); 

end;

این توابع اونقدر ساده هستن که نیاز به هیچ توضیحی ندارن. فقط می مونه تابع merge_array که دو زیر آرایه رو با هم ادغام می کنه.

void merge ( int arr[ ] , int low , int mid , int high) {

register int i , j , k , t; 
j = low; 
for ( i = mid + 1 ; i <= high ; i++)
{
 while ( arr[ j ] <= arr[ i ] && j < i)
  j++; 
 if ( j == i)
  break; 
 t = arr[ i]; 
 for ( k = i ; k > j ; k--) 
  arr[ k ] = arr[ k – 1];
 arr[ j ] = t;
}

}

procedure merge_array ( var arr : array of integer ; l : integer ; m : integer ; h : integer);

var

i , j , k , t : integer; 

begin

j := l; 
for i := m + 1 to h do
begin
 while ( arr[ j ] <= arr[ i ] ) and ( j < i ) do
  inc ( j);
 if j = i then
  break; 
 t := arr[ i];
 for k := i downto j + 1 do
  arr[ k ] := arr[ k – 1];
 arr[ j ] := t;
end; 

End;

تابع merge_array خود آرایه و اندیسهای بالا ، پایین و جداکننده زیر آرایه ای رو که باید ادغام بشه دریافت می کنه ، و به صورت درجا (بدون استفاده از آرایه کمکی) دو قمست مرتب شده زیر آرایه رو ادغام می کنه.

6 - مرتب سازي درجي (Insertion Sort)

مرتب سازي درجي (Insertion Sort) يكي از روشهاي مرتب سازي رايج و البته نه چندان كارا محسوب مي شه. اين روش در مقايسه با مرتب سازي حبابي و انتخابي سرعت بهتري داره و براي مرتب كردن تعداد كمي از عناصر مناسبه. به همين خاطر مراخل انتهايي روش مرتب سازي سريع (Quick Sort) با كمك گرفتن از اين روش انجام مي گيره.

الگوريتم مرتب سازي درجي بر اساس مرتب سازيهايي كه معمولا خود ما بصورت دستي انجام مي ديم طراحي شده. فرض كنيد دسته كارتي با شماره هاي 1 تا 10 بصورت نامرتب و كنار هم روي زمين چيده شدن:

5 2 9 3 1 10 4 6 8 7

كارت دوم رو نسبت به كارت اول در جاي مناسب خودش قرار مي ديم:

2 5 9 3 1 10 4 6 8 7

حالا نوبت به كارت سوم مي رسه. اين كارت رو نسبت به دو كارت قبلي در جاي مناسب قرار مي ديم. چون 9 در مقايسه با 2 و 5 جاي درستي داره بدون هيچ جابجايي به كارت چهارم مي رسيم. جاي اين كارت رو نسبت به سه كارت قبلي مشخص مي كنيم:

2 3 5 9 1 10 4 6 8 7

و به همين ترتيب تا آخر ادامه مي ديم.

اگه n تعداد عناصر رو مشخص كنه ، اين روش n - 1 مرحله رو براي مرتب كردن طي مي كنه. بعد از اتمام مرحله i ام مطمئنا i + 1 عنصر اول به صورت مرتب شده هستن (قسمتي كه زيرشون خط كشيده شده). اين مساله يكي از حسنهاي مرتب سازي درجي محسوب مي شه: در هر مرحله حتما قطعه اي از عناصر مرتب شذه هستن. مرتب سازي حبابي اين ويژگي رو نداره.

پیاده سازی( مرتب سازی درجی) در c++

void insertion_sort ( int arr[ ] , int n)

{

 register int i , j , t; 
(++ for ( i = 1 ; i < n ; i
 }
 ]; t = arr[ i 
  (-- for ( j = i ; j > 0 && arr[ j - 1 ] >= t ; j
    ; arr[ j ] = arr[ j - 1] 
   arr[ i ] = t;
 }

}

7 - مرتب سازي Heep Sort))

يک الگوريتم مرتب سازي در حافظه (RAM) ميباشد. Heap يک درخت دودويي کامل است با ارتفاع Height = ëlog nû هر گره (node) يک کليد بيشتر ندارد که بزرگتر يا برابر کليد گره پدر (parent) ميباشد. بصورت يک آرايه (Array) ذخيره ميشود. براي هر گره (i) فرزندان آن در گره هاي (2i) و (2i+1) ذخيره شده اند. پدر هر گره (j) در گره (j/2) ميباشد.

الگوريتم Insert در Heap Sort چگونه است؟

1) رکورد جديد در آخر Heap اضافه ميشود.

1) کليد آن با کليد گره پدر مقايسه مي شود و اگر مقدار آن کوچکتر بود محل آن با محل گره پدر تعويض ميشود.

1) در صورت لزوم عمل (2) تا ريشه درخت (Root) ادامه مييابد.

الگوريتم Remove در Heap Sort چگونه است؟ 1) کوچکترين کليد که در گره Root ميباشد خارج ميشود. 2) بزرگترين کليد (آخرين گره) به گره Root منتقل ميگردد. 3) کليد آن با کوچکترين کليد فرزند مقايسه مي شود و اگر بيشتر بود جاي آن دو تعويض ميشود. 4) در صورت لزوم عمل (3) تا آخر Heap تکرار ميگردد.

[ویرایش] لیست الگوریتم‌های مرتب‌سازی

در این جدول، n تعداد داده‌ها و k تعداد داده‌ها با کلیدهای متفاوت است. ستون‌های بهترین، میانگین و بدترین، پیچیدگی در هر حالت را نشان می‌دهد و حافظه بیانگر مقدار حافظهٔ کمکی (علاوه بر خود داده‌ها) است.

نام بهترین میانگین بدترین حافظه پایدار مقایسه‌ای‌ روش توضیحات
مرتب سازی حبابی (Bubble sort) (O(n (O(n2 (O(1 بله بله جابجایی Times are for best variant
Cocktail sort (O(n (O(n2 (O(1 بله بله جابجایی
Comb sort (O(n log n (O(n log n (O(1 خیر بله جابجایی
Gnome sort (O(n (O(n2 (O(1 بله بله جابجایی
Selection sort (O(n2 (O(n2 (O(n2 (O(1 خیر بله گزینشی
Insertion sort (O(n (O(n2 (O(1 بله بله درجی
Shell sort (O(n log n (O(n log2n (O(1 خیر بله درجی Times are for best variant
Binary tree sort (O(n log n (O(n log n (O(1 بله بله درجی
Library sort (O(n (O(n log n (O(n2 ε+1)n) بله بله درجی
Merge sort (O(n log n (O(n log n (O(n بله بله Merging
In-place merge sort (O(n log n (O(n log n (O(1 بله بله Merging Times are for best variant
Heapsort (O(n log n (O(n log n (O(1 خیر بله گزینشی
Smoothsort (O(n (O(n log n (O(1 خیر بله گزینشی
Quicksort (O(n log n (O(n log n (O(n2 (O(n خیر بله Partitioning Naive variants use (O(n space
Introsort (O(n log n (O(n log n (O(n log n (O(n خیر بله Hybrid
Pigeonhole sort (O(n+k (O(n+k (O(k بله خیر Indexing
Bucket sort (O(n (O(n (O(n2 (O(k بله خیر Indexing
Counting sort (O(n+k (O(n+k (O(n+k بله خیر Indexing
Radix sort (O(nk (O(nk (O(n بله خیر Indexing
Patience sorting (O(n (O(n log n (O(n خیر بله درجی تمام زیر دنباله‌های صعودی را با (O(n log (log(n پیدا می‌کند.

این جدول الگوریتم‌هایی را توضیح می‌دهد که به علت اجرای بسیار ضعیف و یا نیاز به سخت‌افزار خاص، کاربرد زیادی ندارند.

نام بهترین میانگین بدترین حافظه پایدار مقایسه‌ای توضیحات
Bogosort (O(n O(n × n!) بدون حد (O(1 خیر بله
Stooge sort (O(n2.71 (O(n2.71 (O(1 خیر بله
Bead sort (O(n (O(n N/A خیر به سخت‌افزار مخصوص نیاز دارد.
Pancake sorting (O(n (O(n خیر بله به سخت‌افزار مخصوص نیاز دارد.
Sorting networks (O(log n (O(log n بله بله Requires a custom circuit of size (O(log n

[ویرایش] پاورقی

  1. ^ inplace
  2. ^ stability
تصویر:Computer-stub.png این نوشتار دربارهٔ رایانه ناقص است. با گسترش آن به ویکی‌پدیا کمک کنید.