優化列表<T>。排序（比較器）

Question

我有一個存儲整數丟失的列表。 我不喜歡默認的List.Sort（）工作，因爲我希望列表按實際的int大小排序。 到目前爲止，我有這個：

哦，並且整數存儲在字符串中，例如「1234」。這是我無法改變的。

public class IntComparer : IComparer<string> 
{ 
    public int Compare(string x, string y) 
    { 
     if (x == null) 
     { 
      if (y == null) 
      { 
       // If x is null and y is null, they're 
       // equal. 
       return 0; 
      } 
      else 
      { 
       // If x is null and y is not null, y 
       // is greater. 
       return -1; 
      } 
     } 
     else 
     { 
      // If x is not null... 
      // 
      if (y == null) 
      // ...and y is null, x is greater. 
      { 
       return 1; 
      } 
      else 
      { 
       // ...and y is not null, compare the 
       // lengths of the two strings. 
       // 
       int xInt = Convert.ToInt32(x); 
       int yInt = Convert.ToInt32(y); 

       if (x > y) 
       { 
        // If the strings are not of equal length, 
        // the longer string is greater. 
        // 
        return 1; 
       } 
       else if (xInt == yInt) 
       { 
        return 0; 
       } 
       else 
       { 
        // If the strings are of equal length, 
        // sort them with ordinary string comparison. 


     // 
       return -1; 
      } 
     } 
    } 
} 

但據我所知，這是泡沫排序，正確嗎？ 我應該實施什麼呢？快速排序？另外，我可能需要編寫它的幫助。

哦，我的列表中包含短存儲在字符串

而且號碼2000元，我打電話給我的IComparer是這樣的：

IntComparer intSort = New IntComparer(); 
List<T>.Sort(intSort); 

Answer 1

假設你想存儲爲一個字符串的整數的值進行排序，你可以簡單地做這樣的事情：

numbers.Sort((x,y) => Int32.Parse(x).CompareTo(Int32.Parse(y))); 

Answer 2

你應該知道的是，比較器和排序算法不相互確定。所以這個比較器可以用於冒泡排序以及快速排序，堆排序或任何其他排序算法。根據MSDN，List.Sort的內置排序算法是快速排序。

Answer 3

因此，您有一個表示int的字符串列表作爲輸入，並且您想要一個ints的排序列表作爲輸出嗎？

你似乎在這裏做了很多工作，得到你想要的結果 - 你可以利用一些LINQ到讓你的結果是這樣的：

使用系統;

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

namespace ConsoleApplication6 
{ 
    internal class Program 
    { 
     private static void Main(string[] args) 
     { 
      var unsortedListOfStringsAsInts = new List<string> {"1234", "2345", "7", "9"}; 
      var sortedListOfInts = unsortedListOfStringsAsInts.Select(x => int.Parse(x)).OrderBy(x => x).ToList(); 

      foreach (var i in sortedListOfInts) 
       Console.WriteLine(i); 
     } 
    } 
} 

而且我也不會關心有2千餘種手動優化排序算法 - 這是不是真的這麼多項目進行排序，除非那是「所有」您的應用程序在做什麼。

Answer 4

沒有，用於排序列表中的算法是快速排序，這樣你就可以這不會輕易改善。

List<T>.Sort method

該方法使用Array.Sort，其 使用快速排序算法。

我完成了比較器：

public class IntComparer : IComparer<string> { 

    private static int ParseInt32(string text) { 
     long value = 0; 
     foreach (char c in text) { 
       if (c >= '0' && c <= '9') { 
       value = value * 10 + c - '0'; 
      } else { 
       throw new FormatException(); 
      } 
     } 
     if (value > int.MaxValue) throw new OverflowException(); 
     return (int)value; 
    } 


    public int Compare(string x, string y) { 
     if (x == null) { 
      if (y == null) { 
       // If x is null and y is null, they're 
       // equal. 
       return 0; 
      } else { 
       // If x is null and y is not null, y 
       // is greater. 
       return -1; 
      } 
     } else { 
      // If x is not null... 
      // 
      if (y == null) { 
       // ...and y is null, x is greater. 
       return 1; 
      } else { 
       // ...and y is not null, compare the 
       // lengths of the two strings. 
       // 
       if (x.Length != y.Length) { 
        // If the strings are not of equal length, 
        // the longer string is greater. 
        return x.Length - y.Length; 
       } else { 
        // compare numerically 
        int xInt = ParseInt32(x); 
        int yInt = ParseInt32(y); 
        return xInt - yInt; 
       } 
      } 
     } 
    } 

} 

編輯：
我添加了一個更快的整數解析器。由於比較器不處理負值，解析器也不會，因此可以進一步優化。

Answer 5

這是一個快速的例子，只要你使用.net 3。5項目（LINQ）

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

List<string> unorderedList = List<string>(); 
list.Add("3"); 
list.Add("5"); 
list.Add("2"); 
list.Add("10"); 
list.Add("-6"); 
list.Add("7"); 

List<string> orderedList = list.OrderBy(x => int.Parse(x)).ToList(); 

Answer 6

我想你應該首先將string秒值進行轉換來的int臨時列表如下（迄今爲止）的其他代碼遍地轉換串一遍，每次比較。 （如果保持null的重要性，你也可以使用可爲空的整數）。之後，您對列表進行排序，並在必要時轉換回字符串。