本文由机器翻译。若要查看英语原文,请勾选“英语”复选框。 也可将鼠标指针移到文本上,在弹出窗口中显示英语原文。
翻译
英语

List<T>.Sort 方法 ()

 

使用默认比较器对整个 List<T> 中的元素进行排序。

命名空间:   System.Collections.Generic
程序集:  mscorlib(位于 mscorlib.dll)

public void Sort()

Exception Condition
InvalidOperationException

此默认比较器 Comparer<T>.Default 无法找到 IComparable<T> 泛型接口或类型为 TIComparable 接口的实现。

此方法使用默认比较器 Comparer<T>.Default 类型 T 来确定列表元素的顺序。 Comparer<T>.Default 属性检查是否键入 T 实现 IComparable<T> 泛型接口,并使用该实现中,如果可用。 如果没有, Comparer<T>.Default 检查是否键入 T 实现 IComparable 接口。 如果类型 T 不实现任何接口 Comparer<T>.Default 引发 InvalidOperationException

此方法使用 Array.Sort 方法,后者适用反省排序,如下所示︰

  • 如果分区大小少于 16 个元素,它使用插入排序算法。

  • 如果分区数超过 2 * LogN,其中 N 是范围的输入数组,它使用 Heapsort 算法。

  • 否则,它使用快速排序算法。

此实现将执行不稳定排序;也就是说,如果两个元素相等,可能不会保留它们的顺序。 与此相反,稳定排序保留相等的元素的顺序。

一般情况下,此方法为 O (n 日志 n) 操作,其中 nCount; 最坏的情况是 O (n ^2) 操作。

下面的示例添加到某些名称 List<String> 排序顺序中的列表对象,并显示调用 Sort 方法,然后显示已排序的列表。

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      String[] names = { "Samuel", "Dakota", "Koani", "Saya", "Vanya",
                         "Yiska", "Yuma", "Jody", "Nikita" };
      var nameList = new List<String>();
      nameList.AddRange(names);
      Console.WriteLine("List in unsorted order: ");
      foreach (var name in nameList)
         Console.Write("   {0}", name);

      Console.WriteLine(Environment.NewLine);

      nameList.Sort();
      Console.WriteLine("List in sorted order: ");
      foreach (var name in nameList)
         Console.Write("   {0}", name);

      Console.WriteLine();
   }
}
// The example displays the following output:
//    List in unsorted order:
//       Samuel   Dakota   Koani   Saya   Vanya   Yiska   Yuma   Jody   Nikita
//
//    List in sorted order:
//       Dakota   Jody   Koani   Nikita   Samuel   Saya   Vanya   Yiska   Yuma

下面的代码演示 Sort()Sort(Comparison<T>) 简单的业务对象上的方法重载。 调用 Sort() 方法会导致对部件类型使用默认比较器和 Sort(Comparison<T>) 方法通过使用匿名方法实现。

using System;
using System.Collections.Generic;
// Simple business object. A PartId is used to identify the type of part 
// but the part name can change. 
public class Part : IEquatable<Part> , IComparable<Part>
{
    public string PartName { get; set; }

    public int PartId { get; set; }

    public override string ToString()
    {
        return "ID: " + PartId + "   Name: " + PartName;
    }
    public override bool Equals(object obj)
    {
        if (obj == null) return false;
        Part objAsPart = obj as Part;
        if (objAsPart == null) return false;
        else return Equals(objAsPart);
    }
    public int SortByNameAscending(string name1, string name2)
    {

        return name1.CompareTo(name2);
    }

    // Default comparer for Part type.
    public int CompareTo(Part comparePart)
    {
          // A null value means that this object is greater.
        if (comparePart == null)
            return 1;

        else
            return this.PartId.CompareTo(comparePart.PartId);
    }
    public override int GetHashCode()
    {
        return PartId;
    }
    public bool Equals(Part other)
    {
        if (other == null) return false;
        return (this.PartId.Equals(other.PartId));
    }
    // Should also override == and != operators.

}
public class Example
{
    public static void Main()
    {
        // Create a list of parts.
        List<Part> parts = new List<Part>();

        // Add parts to the list.
        parts.Add(new Part() { PartName = "regular seat", PartId = 1434 });
        parts.Add(new Part() { PartName= "crank arm", PartId = 1234 });
        parts.Add(new Part() { PartName = "shift lever", PartId = 1634 }); ;
        // Name intentionally left null.
        parts.Add(new Part() {  PartId = 1334 });
        parts.Add(new Part() { PartName = "banana seat", PartId = 1444 });
        parts.Add(new Part() { PartName = "cassette", PartId = 1534 });


        // Write out the parts in the list. This will call the overridden 
        // ToString method in the Part class.
        Console.WriteLine("\nBefore sort:");
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }


        // Call Sort on the list. This will use the 
        // default comparer, which is the Compare method 
        // implemented on Part.
        parts.Sort();


        Console.WriteLine("\nAfter sort by part number:");
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

        // This shows calling the Sort(Comparison(T) overload using 
        // an anonymous method for the Comparison delegate. 
        // This method treats null as the lesser of two values.
        parts.Sort(delegate(Part x, Part y)
        {
            if (x.PartName == null && y.PartName == null) return 0;
            else if (x.PartName == null) return -1;
            else if (y.PartName == null) return 1;
            else return x.PartName.CompareTo(y.PartName);
        });

        Console.WriteLine("\nAfter sort by name:");
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

        /*

            Before sort:
		ID: 1434   Name: regular seat
		ID: 1234   Name: crank arm
		ID: 1634   Name: shift lever
		ID: 1334   Name:
		ID: 1444   Name: banana seat
		ID: 1534   Name: cassette

	    After sort by part number:
		ID: 1234   Name: crank arm
		ID: 1334   Name:
		ID: 1434   Name: regular seat
		ID: 1444   Name: banana seat
		ID: 1534   Name: cassette
		ID: 1634   Name: shift lever

	    After sort by name:
		ID: 1334   Name:
		ID: 1444   Name: banana seat
		ID: 1534   Name: cassette
		ID: 1234   Name: crank arm
		ID: 1434   Name: regular seat
		ID: 1634   Name: shift lever

         */

    }
}

下面的示例演示 Sort() 方法重载与 BinarySearch(T) 方法重载。 一个 List<T> 的字符串创建并填充了四个字符串,顺序不分先后。 此列表显示、 排序,并且再次显示。

BinarySearch(T) 方法重载然后用于不在列表中,这两个字符串中搜索与 Insert 方法用来将它们插入。 返回值 BinarySearch 方法中为负每种情况下,由于字符串不是在列表中。 执行按位求补 (~ 运算符在 C# 和 Visual c + +, Xor 在 Visual Basic 中的为-1) 的此负的数字生成大于整个搜索字符串,并将在此位置中的列表中的第一个元素的索引保留排序顺序。 第二个搜索字符串大于任何元素在列表中,因此插入位置位于列表的末尾。

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();

        dinosaurs.Add("Pachycephalosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nSort");
        dinosaurs.Sort();

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nBinarySearch and Insert \"Coelophysis\":");
        int index = dinosaurs.BinarySearch("Coelophysis");
        if (index < 0)
        {
            dinosaurs.Insert(~index, "Coelophysis");
        }

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nBinarySearch and Insert \"Tyrannosaurus\":");
        index = dinosaurs.BinarySearch("Tyrannosaurus");
        if (index < 0)
        {
            dinosaurs.Insert(~index, "Tyrannosaurus");
        }

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

Sort

Amargasaurus
Deinonychus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Coelophysis":

Amargasaurus
Coelophysis
Deinonychus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Tyrannosaurus":

Amargasaurus
Coelophysis
Deinonychus
Mamenchisaurus
Pachycephalosaurus
Tyrannosaurus
 */

通用 Windows 平台
自 8 起可用
.NET Framework
自 2.0 起可用
可移植类库
可移植 .NET 平台 中受支持
Silverlight
自 2.0 起可用
Windows Phone Silverlight
自 7.0 起可用
Windows Phone
自 8.1 起可用
返回页首
显示: