.NET 中是否有 SortedList<T> 类？

Question

我需要根据它们的内容对一些对象进行排序（实际上是根据它们的属性之一，这不是关键，并且可能在不同的对象之间重复）。

.NET 提供了两个类（SortedDictionary 和SortedList），它们都是使用二叉树实现的。它们之间的唯一区别是

• SortedList 使用的内存少于 SortedDictionary。
• SortedDictionary 对未排序的数据具有更快的插入和删除操作，O(log n) 相对于 SortedList 的 O(n)。
• 如果列表是从排序数据一次性填充的，SortedList 比 SortedDictionary 快。

我可以使用List, 来实现我想要的，然后使用它的Sort() 方法和IComparer 的自定义实现，但这并不省时，因为我每次都需要对整个列表进行排序插入一个新对象，而一个好的 SortedList 只会在正确的位置插入项目。

我需要的是一个带有 RefreshPosition(int index) 的 SortedList 类，用于仅移动已更改（或插入）的对象，而不是在每次内部对象更改时重新使用整个列表。

我是否遗漏了一些明显的东西？

Answer 1

也许我很慢，但这不是最简单的实现吗？

class SortedList<T> : List<T>
{
    public new void Add(T item)
    {
        Insert(~BinarySearch(item), item);
    }
}

http://msdn.microsoft.com/en-us/library/w4e7fxsh.aspx

---

不幸的是，Add 是不可覆盖的，所以我不得不 new 它，当你有 List<T> list = new SortedList<T>; 时，这不是很好，我实际上需要这样做......所以我继续重建整个东西……

class SortedList<T> : IList<T>
{
    private List<T> list = new List<T>();

    public int IndexOf(T item)
    {
        var index = list.BinarySearch(item);
        return index < 0 ? -1 : index;
    }

    public void Insert(int index, T item)
    {
        throw new NotImplementedException("Cannot insert at index; must preserve order.");
    }

    public void RemoveAt(int index)
    {
        list.RemoveAt(index);
    }

    public T this[int index]
    {
        get
        {
            return list[index];
        }
        set
        {
            list.RemoveAt(index);
            this.Add(value);
        }
    }

    public void Add(T item)
    {
        list.Insert(~list.BinarySearch(item), item);
    }

    public void Clear()
    {
        list.Clear();
    }

    public bool Contains(T item)
    {
        return list.BinarySearch(item) >= 0;
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        list.CopyTo(array, arrayIndex);
    }

    public int Count
    {
        get { return list.Count; }
    }

    public bool IsReadOnly
    {
        get { return false; }
    }

    public bool Remove(T item)
    {
        var index = list.BinarySearch(item);
        if (index < 0) return false;
        list.RemoveAt(index);
        return true;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return list.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return list.GetEnumerator();
    }
}

---

或者也许这样的东西是更合适的Remove函数...

    public bool Remove(T item)
    {
        var index = list.BinarySearch(item);
        if (index < 0) return false;
        while (((IComparable)item).CompareTo((IComparable)list[index]) == 0)
        {
            if (item == list[index])
            {
                list.RemoveAt(index);
                return true;
            }
            index++;
        }
        return false;
    }

假设项目可以比较相等但不相等......

Answer 2

我最终决定写它：

class RealSortedList<T> : List<T>
    {
        public IComparer<T> comparer;

        public int SortItem(int index)
        {
            T item = this[index];
            this.RemoveAt(index);
            int goodposition=FindLocation(this[index], 0, this.Count);
            this.Insert(goodposition, item);
            return goodposition;
        }

        public int FindLocation(T item, int begin, int end)
        {
            if (begin==end)
                return begin;
            int middle = begin + end / 2;
            int comparisonvalue = comparer.Compare(item, this[middle]);
            if (comparisonvalue < 0)
                return FindLocation(item,begin, middle);
            else if (comparisonvalue > 0)
                return FindLocation(item,middle, end);
            else
                return middle;
        }
    }

Answer 3

不要忘记，将项目插入由数组支持的列表可能是一项昂贵的操作 - 插入一堆项目然后排序可能会更快，除非您真的需要在每次操作后进行排序。

或者，您总是可以包装一个列表并让您的添加操作找到正确的位置并将其插入那里。

Answer 4

我过去通过编写一个扩展方法来解决这个问题，该方法在 IList 上执行二进制搜索，另一个执行插入操作。您可以在 CLR 源代码中查找正确的实现，因为有一个仅适用于数组的内置版本，然后只需将其调整为 IList 上的扩展。

其中一个“应该已经在 BCL 中”的东西。

Answer 5

我需要的是一个 SortedList 类 一个 RefreshPosition(int index) 移动 仅更改（或插入）的对象 而不是诉诸整个列表 每次内部对象发生变化时。

当此类更新使索引无效时，为什么要使用 索引 进行更新？真的，我认为通过对象引用进行更新会更方便。您可以使用 SortedList 执行此操作 - 只需记住您的 Key 类型与从对象中提取可比较数据的函数的返回类型相同。

class UpdateableSortedList<K,V> {
    private SortedList<K,V> list = new SortedList<K,V>();
    public delegate K ExtractKeyFunc(V v);
    private ExtractKeyFunc func;

    public UpdateableSortedList(ExtractKeyFunc f) { func = f; }

    public void Add(V v) {
        list[func(v)] = v;
    }
    public void Update(V v) {
        int i = list.IndexOfValue(v);
        if (i >= 0) {
            list.RemoveAt(i);
        }
        list[func(v)] = v;
    }
    public IEnumerable<T> Values { get { return list.Values; } }
}

我猜是这样的。