Question: I have a SortedDictionary where I am holding points of a particular player and his name next to it. What I need to do is to sort this in a descending order so that I have the winner in the first position of the dictionary. How can I do that?

Also, how can I get an item from the list without knowing the key?

```
SortedDictionary<int, string> dict = new SortedDictionary<int, string>();
dict.Add(player1Pts, playerNames[0]);
dict.Add(player2Pts, playerNames[1]);
dict.Add(player3Pts, playerNames[2]);

```

Thanks for any help!

Answer: 
It doesn't really make sense to use a dictionary with the score as the key: the key must be unique, so it will fail if two players have the same score.

Instead, you should create a `Player` class that contains the name and score, and store `Player` objects in a `List<Player>`. If you need to sort the players by score, you can call `Sort` on the list with a custom comparer, or just order the result with Linq:

```
foreach (Player player in players.OrderByDescending(p => p.Score))
{
    // Do something with player
}

```
While there are several answers to the question, none of these seem to take advantage of the SortedDictionary structure. If you want the SortedDictionary to be designed as a max heap rather than the default min heap, I think the best solution is to overwrite the default comparer that C# uses. This can be done as follows:

```
public class DescendingComparer<T>: IComparer<T> where T : IComparable<T>
{
    public int Compare(T x, T y)
    {
        return y.CompareTo(x); //reverses, so compare ascending
                 //this is vs the standard method, which returns x.CompareTo(y)
    }

}

static void Main(string[] args)
{

SortedDictionary<float, string> myDict = new SortedDictionary<float,string>(new DescendingComparer<float>()); //sorts on the key
    string[] name = {"Bill", "Tom", "Susan", "Terry"};
    myDict.Add(.8f, name[0]);
    myDict.Add(.2f, name[1]);
    myDict.Add(.95f, name[2]);
    myDict.Add(.005f, name[4]);

    foreach (KeyValuePair<float, int> j in myDict)
    {
        Console.WriteLine("Key: {0}, Value: {1}",j.Key,j.Value);
    } //now it is stored in increasing order, so accessing largest elements fast
}

```

See also, here: [C#: sort dictionary in descending order](https://stackoverflow.com/questions/2807461/c-sort-dictionary-in-descending-order)