按字母顺序排序列表

我有以下课程:

class Detail
{
public Detail()
{
_details = new List<string>();
}
public IList<string> Details { get { return _details; } }
private readonly List<string> _details;
}

目前，我使用以下方法对类进行随机排序:

void ShuffleGenericList<T>(IList<T> list)
{
//generate a Random instance
var rnd = new Random();
//get the count of items in the list
var i = list.Count();
//do we have a reference type or a value type
T val = default(T);


//we will loop through the list backwards
while (i >= 1)
{
//decrement our counter
i--;
//grab the next random item from the list
var nextIndex = rnd.Next(i, list.Count());
val = list[nextIndex];
//start swapping values
list[nextIndex] = list[i];
list[i] = val;
}
}

我想要做的是按字母顺序对细节内容进行排序。

例如，如果内容是这样的:

[0] a
[1] d
[2] b

我希望能够运行这个方法，并将它们分类为:

[0] a
[1] b
[2] d

有人知道一个简单的方法吗？请注意，这些列表中通常只有不到10个条目。我能用 LINQ 做这个吗？对不起，我不是很熟悉 LINQ，我刚刚听到一个建议，我可以使用它。

267319 次浏览
小开

You should be able to use OrderBy in LINQ...

var sortedItems = myList.OrderBy(s => s);
小开
最佳答案

You can sort a list in-place just by calling List<T>.Sort:

list.Sort();

That will use the natural ordering of elements, which is fine in your case.

EDIT: Note that in your code, you'd need

_details.Sort();

as the Sort method is only defined in List<T>, not IList<T>. If you need to sort it from the outside where you don't have access to it as a List<T> (you shouldn't cast it as the List<T> part is an implementation detail) you'll need to do a bit more work.

I don't know of any IList<T>-based in-place sorts in .NET, which is slightly odd now I come to think of it. IList<T> provides everything you'd need, so it could be written as an extension method. There are lots of quicksort implementations around if you want to use one of those.

If you don't care about a bit of inefficiency, you could always use:

public void Sort<T>(IList<T> list)
{
List<T> tmp = new List<T>(list);
tmp.Sort();
for (int i = 0; i < tmp.Count; i++)
{
list[i] = tmp[i];
}
}

In other words, copy, sort in place, then copy the sorted list back.

You can use LINQ to create a new list which contains the original values but sorted:

var sortedList = list.OrderBy(x => x).ToList();

It depends which behaviour you want. Note that your shuffle method isn't really ideal:

  • Creating a new Random within the method runs into some of the problems shown here
  • You can declare val inside the loop - you're not using that default value
  • It's more idiomatic to use the Count property when you know you're working with an IList<T>
  • To my mind, a for loop is simpler to understand than traversing the list backwards with a while loop

There are other implementations of shuffling with Fisher-Yates on Stack Overflow - search and you'll find one pretty quickly.

小开

What is wrong with List<T>.Sort()?

https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.list-1.sort#overloads

小开

There are two ways:

Without LINQ: yourList.Sort();

With LINQ: yourList.OrderBy(x => x).ToList()

You will find more information in: https://www.dotnetperls.com/sort

小开

Another way

_details.Sort((s1, s2) => s1.CompareTo(s2));

提交答案