سی# میں چھوٹے چھوٹے انگرس کو ترتیب دینے کے لئے بڑے سیٹنگ کی ترتیب

جب آپکا طریقہ کار بہت بڑا ہوتا ہے چھوٹے انگرس کا عدد — جیسے ڈگری، عمر یا پھر اس سے متعلقہ کوڈ — کلاسیکی موازنہ پر مبنی الجبرا جیسے جلدی شور یا میرج سائیڈ کی طرح محسوس کر سکتے ہیں. یہ یقینی مقداریں او(ن لاگ n) وقت میں دوڑنے کے قابل ہوتے ہیں، لیکن اگر ممکنہ مقداریں محدود ہیں تو آپ ترتیب وار اوور(ن لاگ) کے ساتھ ترتیب دے سکتے ہیں [Tools/Tools]]] مگر یہ آپ دونوں کا موازنہ کر سکتے ہیں

کام کے حساب سے کیا مُراد ہے ؟

اس سے حاصل ہونے والے ذرات کو اس بات کا اندازہ ہوتا ہے کہ انتہائی معمولی مقدار میں موجود انفنٹریز (fLT:0] سے بنے ہوتے ہیں ۔

بنیادی مقاصد : درست دوبارہ تعمیر

شمارندی طرز کا سب سے آسان نسخہ دو سیر میں کام کرتا ہے:

1. رقبہ فریکوئنسی – Incent struction کے ذریعے اور ہر قیمت کے لیے ایک مقابلہ آپ دیکھ سکتے ہیں.
2. اتارنے کی صلاحیت – کرنٹ کے ذریعے چلنے والا ایک چھوٹا سے بڑے سے بڑے قطروں سے گزرتا ہے اور ہر قیمت کے لیے اسے اپنی گنتی کے لحاظ سے بہت بار ان پٹ میں شامل کر کے دوبارہ شامل کر لیتا ہے۔

یہ تقسیمی پیداوار کرتا ہے لیکن نہیں [1] [1] کوئي متعلقہ ترتیب محفوظ رکھیں (سي طور پر قائم نہیں ہے).

اسٹیبل وریبات: Comulative countys -

نظام کو مستحکم بنانے کے لیے ہم ایک تیسرے دور کو شامل کرتے ہیں:

1. پہلے کی طرح نمبر فریکوکینس۔
2. [ فٹ‌نوٹ : ۲۰ ]
3. اِس کے بعد کے اجزا کو واپس موڑ کر اُس کے گرد رکھ دیں ( پچھلے عناصر سے شروع تک ) ۔

کیونکہ ہم پیچھے چلتے ہیں، برابر عناصر کی ترتیب محفوظ ہے. خروج کی فضاء ان پٹ سے الگ ہے، اس طرح یہ نسخہ برآمد کے لیے O(n) اضافی جگہ استعمال کرتا ہے جبکہ بنیادی نسخہ ان پٹ پر درج کرنے سے اس طرح میں موجود ہو سکتا ہے۔

سی# میں شمار کرنے کا طریقہ

نیچے دو سی# عمل آوری: بنیادی طور پر بنیادی نسخے (جس میں استحکام ضروری ہو) اور وہ پائیدار نسخہ جو کسی معاون (Ad مدد) کو استعمال کرتا ہو، دونوں کو آگے کی طرف سے سب سے زیادہ قیمت معلوم کرنا پڑتی ہے۔

بنیادی (Non ⁇ stable) قسم کا حساب دینا

یہ ایک غیرمعمولی پیداوار کے بغیر براہِ‌راست مختلف قسم کے داخلی نظام رکھتا ہے ۔

public static void CountingSortBasic(int[] array, int maxValue)
{
 int[] counts = new int[maxValue + 1];

 // Count each element's frequency
 for (int i = 0; i < array.Length; i++)
 {
 counts[array[i]]++;
 }

 // Overwrite the original array in sorted order
 int index = 0;
 for (int value = 0; value <= maxValue; value++)
 {
 while (counts[value]-- > 0)
 {
 array[index++] = value;
 }
 }
}

معیاروں کے حساب

اسکے علاوہ ، یہ بہت اہم ہے کہ ہم اپنے نصب‌العین کو درست طور پر مرتب کرنے کیلئے بھی استعمال کریں ۔

public static int[] CountingSortStable(int[] array, int maxValue)
{
 int[] counts = new int[maxValue + 1];
 int[] output = new int[array.Length];

 // Step 1: Count occurrences
 foreach (int num in array)
 {
 counts[num]++;
 }

 // Step 2: Transform counts to cumulative counts
 for (int i = 1; i <= maxValue; i++)
 {
 counts[i] += counts[i - 1];
 }

 // Step 3: Build the output array (iterate input in reverse for stability)
 for (int i = array.Length - 1; i >= 0; i--)
 {
 int value = array[i];
 output[counts[value] - 1] = value;
 counts[value]--;
 }

 return output;
}

دونوں عمل میں سب سے بڑا انفنٹری ہے جو صف میں ظاہر ہوتا ہے اگر سچن زیادہ معلوم نہیں ہوتا تو آپ اسے پریفیکچر (O((n)) سے شمار کرسکتے ہیں ۔

پیچیدہ تجزیہ

[1] [1] عناصر اور ]]] = Max – Min + 1 (ایک ممکنہ اقدار کا قطر)۔

public static int[] CountingSortWithNegative(int[] array)
{
 if (array.Length == 0) return array;

 int min = array.Min();
 int max = array.Max();
 int range = max - min + 1;

 int[] counts = new int[range];
 int[] output = new int[array.Length];

 foreach (int num in array)
 counts[num - min]++;

 for (int i = 1; i < range; i++)
 counts[i] += counts[i - 1];

 for (int i = array.Length - 1; i >= 0; i--)
 {
 int value = array[i];
 output[counts[value - min] - 1] = value;
 counts[value - min]--;
 }

 return output;
}

n = 1,000,000 | k = 1,000
Array.Sort (QuickSort variant) : 68 ms
CountingSortBasic : 12 ms
CountingSortStable : 18 ms