Question

为什么只有SortedList<TKey, TValue>看起来更像是字典，但没有SortedList<T>实际上只是一个总是排序的列表？

根据the MSDN documentation on SortedList，它实际上是在内部实现为动态大小的KeyValuePair<TKey, TValue>数组，始终按键排序。作为任何类型T的列表，同一个类不会更有用吗？那个名字也不合适吗？

Answer 1

虽然没有人能真正告诉你为什么没有SortedList<T>，但可以讨论为什么SortedList获取密钥和值。字典将键映射到值。执行此操作的典型方法是使用二叉树，哈希表和列表（数组），尽管哈希表最常见，因为对于大多数操作它们都是O（1）。

它在O（1）中不支持的主要操作是按顺序获取下一个键。如果您希望能够这样做，通常使用二叉树，为您提供排序字典。

如果您决定将地图实现为列表，则应保持按键排序的元素，以便查找为O（lg n），为您提供另一个排序字典 - 以排序列表的形式。当然，名称SortedDictionary已经被采用，但SortedList却没有。我可能已将其称为SortedListDictionary或SortedDictionaryList，但我没有将其命名。

Answer 2

现在有：）

public class SortedList<T> : ICollection<T>
{
    private List<T> m_innerList;
    private Comparer<T> m_comparer;

    public SortedList() : this(Comparer<T>.Default)
    {
    }

    public SortedList(Comparer<T> comparer)
    {
        m_innerList = new List<T>();
        m_comparer = comparer;
    }

    public void Add(T item)
    {
        int insertIndex = FindIndexForSortedInsert(m_innerList, m_comparer, item);
        m_innerList.Insert(insertIndex, item);
    }

    public bool Contains(T item)
    {
        return IndexOf(item) != -1;
    }

    /// <summary>
    /// Searches for the specified object and returns the zero-based index of the first occurrence within the entire SortedList<T>
    /// </summary>
    public int IndexOf(T item)
    {
        int insertIndex = FindIndexForSortedInsert(m_innerList, m_comparer, item);
        if (insertIndex == m_innerList.Count)
        {
            return -1;
        }
        if (m_comparer.Compare(item, m_innerList[insertIndex]) == 0)
        {
            int index = insertIndex;
            while (index > 0 && m_comparer.Compare(item, m_innerList[index - 1]) == 0)
            {
                index--;
            }
            return index;
        }
        return -1;
    }

    public bool Remove(T item)
    {
        int index = IndexOf(item);
        if (index >= 0)
        {
            m_innerList.RemoveAt(index);
            return true;
        }
        return false;
    }

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

    public void CopyTo(T[] array)
    {
        m_innerList.CopyTo(array);
    }

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

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

    public T this[int index]
    {
        get
        {
            return m_innerList[index];
        }
    }

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

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

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

    public bool IsReadOnly
    {
        get
        {
            return false;
        }
    }

    public static int FindIndexForSortedInsert(List<T> list, Comparer<T> comparer, T item)
    {
        if (list.Count == 0)
        {
            return 0;
        }

        int lowerIndex = 0;
        int upperIndex = list.Count - 1;
        int comparisonResult;
        while (lowerIndex < upperIndex)
        {
            int middleIndex = (lowerIndex + upperIndex) / 2;
            T middle = list[middleIndex];
            comparisonResult = comparer.Compare(middle, item);
            if (comparisonResult == 0)
            {
                return middleIndex;
            }
            else if (comparisonResult > 0) // middle > item
            {
                upperIndex = middleIndex - 1;
            }
            else // middle < item
            {
                lowerIndex = middleIndex + 1;
            }
        }

        // At this point any entry following 'middle' is greater than 'item',
        // and any entry preceding 'middle' is lesser than 'item'.
        // So we either put 'item' before or after 'middle'.
        comparisonResult = comparer.Compare(list[lowerIndex], item);
        if (comparisonResult < 0) // middle < item
        {
            return lowerIndex + 1;
        }
        else
        {
            return lowerIndex;
        }
    }
}

Answer 3

我认为原因可能只是List<T>已经有BinarySearch和Insert，这意味着实现自己的常规排序列表很简单。

这并不意味着SortedList<T>类不属于框架 - 只是它可能不是一个非常高的优先级，因为任何需要它的开发人员都可以很容易地编写它。

我认为HashSet<T>也是如此，因为你可以很容易地使用Dictionary<T, byte>（例如）在.NET 3.5之前模拟一个UniqueSet<T>。

我知道这就是我在两种情况下所做的事情：我有一个AlwaysSortedList<T>课程和一个Dictionary<T, byte>课程，它只包含List<T>和BinarySearch（并使用过）分别为Insert和{{1}}）。

Answer 4

我认为解决这个问题的方法是实现一个以排序方式添加List<T>的扩展方法（只需2行代码;），然后List<T>可以用作排序列表（假设您避免使用List.Add(...)）：

    public static void AddSorted<T>(this List<T> list, T value)
    {
        int x = list.BinarySearch(value);
        list.Insert((x >= 0) ? x : ~x, value);
    }

Answer 5

这是一个按键完成排序的列表。我只是推测，但通过提供指定与元素分开的键的能力，您的元素不必具有可比性 - 只需要键。我想，在一般情况下，这会节省大量用于实现IComparable的代码，因为密钥可能是一种已经可比较的类型。

Answer 6

RPM评论非常有效。此外，使用Linq扩展，您可以使用Sort扩展方法对T的任何属性进行排序。我认为这可能是其背后的主要原因。

为什么.NET中没有SortedList <t>？</t>

6 个答案: