Sắp xếp các tập hợp số nguyên nhỏ ở C#

Khi nhiệm vụ sắp xếp của bạn bao gồm một loạt số nguyên nhỏ, số nhiều, tuổi, hoặc mật mã phân loại - các thuật toán sử dụng so sánh cổ điển như QuickSort hoặc ert có thể cảm thấy bị giết. Những thuật toán này chạy trong thời gian O(n log n) thời gian, nhưng nếu phạm vi của giá trị có thể là giới hạn, bạn có thể sắp xếp trong thời gian [FL: 0] thời gian [FL: 0] Sắp xếp [FLT]. Việc sắp xếp [FL:1]. Thuật toán không tương ứng này có lợi thế cho phép tính các yếu tố có thể xảy ra, bạn có thể tính các yếu tố không phải là một dạng ổn định và cả hai quyền sử dụng nhanh.

Làm thế nào tính việc sắp xếp?

Tính

Cách tiếp cận cơ bản: Trực tiếp hồi phục

Phiên bản đơn giản nhất của Sắp xếp đếm hoạt động trong hai lần đi qua:

1. Tần số – Nó chạy qua các dòng đầu vào và tăng dần một máy đếm cho mỗi giá trị bạn thấy.
2. Vượt quá việc ghi – đi qua các dãy đối chiếu từ nhỏ nhất đến lớn nhất và, cho mỗi giá trị, ghi nó trở lại vào các dòng nhập nhiều lần như số đếm của nó.

Điều này mang lại kết quả đã sắp xếp nhưng không [FLT: 0] [FLT: 1] bảo tồn thứ tự tương đối của bản sao (nó không ổn định). Tính bền vững là khi bạn sắp xếp trên phím, trong khi giữ thứ tự gốc của tài liệu bằng. Biến thể ổn định, được miêu tả tiếp theo, là thứ tự thường dùng nhất trong thực tế.

Sự đa dạng có thể được: Số đếm được chữa lành

Để làm cho việc đếm được ổn định, chúng ta thêm một lần thứ ba:

1. Đếm tần số như trước.
2. Biến dãy tần số thành dãy đếm tích lũy. Sau bước này, giữ số yếu tố [FLT: 0]i .
3. Hãy lặp lại dãy nhập theo chiều ngược (từ yếu tố cuối cho đến bước đầu tiên). Đối với mỗi yếu tố, hãy dùng số đếm tích lũy của nó để tìm vị trí của nó trong dãy kết xuất, đặt nó và giảm số đếm.

Bởi vì chúng ta đi ngược lại, thứ tự tương đối của các nguyên tố bằng được bảo tồn.

Phân loại đếm trong C#

Dưới đây là hai C# thực hiện: phiên bản ở nơi (cho những tình huống không cần thiết) và phiên bản ổn định sử dụng một dãy phụ trợ. Cả hai đều yêu cầu biết giá trị tối đa trước.

Cơ bản (không có) Sắp xếp đếm

Biến thể này sắp xếp trực tiếp các mảng nhập mà không cần bộ đệm xuất thêm. Nó là bộ nhớ hiệu quả nhưng không ổn định.

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

Sắp xếp đếm được

Phiên bản ổn định đòi hỏi một chuỗi xuất cùng kích cỡ với dữ liệu nhập. Nó cũng dùng tích lũy để định vị các phần tử đúng.

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

Trong cả hai việc thực hiện, là số nguyên lớn nhất xuất hiện trong mảng. Nếu tối đa thật là không rõ, bạn có thể tính toán nó với một bản quét chuẩn (O(n). Phiên bản ổn định trả về một dãy mới, để lại bản gốc không thay đổi.

Phân tích độ phức tạp

Hãy n là số nguyên tố và = tối đa – min + 1 (tải giá trị có thể).

• Thời gian :) Sắp xếp đếm chạy ) O(n + k] . Thời gian đếm là O(n), tiền tố tích lũy là O(k), và sự tái tạo là O(n). Khi k là O(n), thuật toán tuyến tính.
• [FLT: 0] Không gian [FLT: 1] phiên bản cơ bản dùng thêm O (k) cho mảng đếm. Phiên bản ổn định dùng O(n + k) vì nó cũng phân bổ các mảng xuất. Tính năng này sẽ không thích hợp khi phạm vi lớn tương ứng với số mục.
• Máy tính đáp ứng với các loại khác: so sánh các loại dựa trên QuickSort và Port yêu cầu ít nhất O(n log n). Đối với k (v. d., k < 10,000 & ng; 100.000), sắp xếp đếm có thể là thứ tự nhanh hơn.

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