【C#】連想配列(Dictionary)を値 or キーでソート

　このテーマはググればいくらでも出てくるので、どちらかというと自分用メモ。先に述べてしまうと、初めの LINQ 的な書き方が一番簡単だろう。ただ、他の方法もあったので、それも少しまとめてみた感じ。色々な書き方を知っておくと、他言語に移植するとき等にも役に立つからだ。

■IEnumerableでのソート (LINQ)
■KeyValuePair の List でのソート (ラムダ式)
■KeyValuePair の List でのソート (delegate)
■KeyValuePair の List でのソート (IComparer)
■キーと値の２つの配列でのソート

---

■IEnumerable でのソート (LINQ)

　LINQ (System.Linq) が使えるなら、とりあえずこれを使うのが一番楽だろう。内容的には Enumerable(IEnumerable) を使うことになる。キーでのソートも、値でのソートもプロパティを変えるだけで同様にできる。

●値でのソート (IEnumerable)

using System;
using System.Collections.Generic;
using System.Linq;

Dictionary<string, int> dic = new Dictionary<string, int>() {
    { "Becky", 85 },
    { "Daisy", 72 },
    { "Alice", 95 },
    { "Eliza", 78 },
    { "Cindy", 100 },
};

var sorted = dic.OrderBy((x) => x.Value);  //昇順
//var sorted = dic.OrderByDescending((x) => x.Value);  //降順

foreach (var v in sorted)
{
    Console.WriteLine(v.Key + " => " + v.Value);
}

Daisy => 72
Eliza => 78
Becky => 85
Alice => 95
Cindy => 100

　コメントアウトの方は降順になる。キーでのソートはソート対象を変えるだけで良い（x.Value → x.Key に変更）。

●キーでのソート (IEnumerable)

var sorted = dic.OrderBy((x) => x.Key);  //昇順
//var sorted = dic.OrderByDescending((x) => x.Key);  //降順

Alice => 95
Becky => 85
Cindy => 100
Daisy => 72
Eliza => 78

---

■KeyValuePair の List でのソート (ラムダ式)

　これはキーと値のペア（KeyValuePair）のリストを作って、それをソートする方法だ。他の言語でもよく使われる方法なので、覚えておくと役に立つ。List.Sort() はラムダ式が使えるようなので、簡潔に書くことも可能だ。

●値でのソート (KeyValuePair の List と ラムダ式)

using System;
using System.Collections.Generic;

Dictionary<string, int> dic = new Dictionary<string, int>() {
    { "Becky", 85 },
    { "Daisy", 72 },
    { "Alice", 95 },
    { "Eliza", 78 },
    { "Cindy", 100 },
};

List<KeyValuePair<string, int>> list = new List<KeyValuePair<string, int>>(dic);
list.Sort((a, b) => a.Value - b.Value);  //昇順
//list.Sort((a, b) => b.Value - a.Value);  //降順

foreach (var v in list)
{
    Console.WriteLine(v.Key + " => " + v.Value);
}

Daisy => 72
Eliza => 78
Becky => 85
Alice => 95
Cindy => 100

　コメントアウトの方は降順になる。キーでのソートはソート対象を変えるだけで良い（x.Value → x.Key に変更）。なお、比較には CompareTo() を使っている。

●キーでのソート (KeyValuePair の List と ラムダ式)

list.Sort((a, b) => a.Key.CompareTo(b.Key));  //昇順
//list.Sort((a, b) => b.Key.CompareTo(a.Key));  //降順

Alice => 95
Becky => 85
Cindy => 100
Daisy => 72
Eliza => 78

---

■KeyValuePair の List でのソート (delegate)

　これは上記のラムダ式版の別表記と言っても良いのだが、改めて delegate を使えると覚えておくと、例えば、リアルタイムにソート方法を変更するような実装もできると考えることができる。まぁ、引き出しは多いことに越したことはない。

●値でのソート (KeyValuePair の List と delegate)

using System;
using System.Collections.Generic;

Dictionary<string, int> dic = new Dictionary<string, int>() {
    { "Becky", 85 },
    { "Daisy", 72 },
    { "Alice", 95 },
    { "Eliza", 78 },
    { "Cindy", 100 },
};

List<KeyValuePair<string, int>> list = new List<KeyValuePair<string, int>>(dic);
list.Sort(delegate(KeyValuePair<string, int> a, KeyValuePair<string, int> b) {
    return a.Value - b.Value;  //昇順
    //return b.Value - a.Value;  //降順
});

foreach (var v in list)
{
    Console.WriteLine(v.Key + " => " + v.Value);
}

Daisy => 72
Eliza => 78
Becky => 85
Alice => 95
Cindy => 100

　コメントアウトの方は降順になる。キーでのソートはソート対象を変えるだけで良い（x.Value → x.Key に変更）。なお、比較には CompareTo() を使っている。

●キーでのソート (KeyValuePair の List と delegate)

list.Sort(delegate(KeyValuePair<string, int> a, KeyValuePair<string, int> b) {
    return a.Key.CompareTo(b.Key);  //昇順
    //return b.Key.CompareTo(a.Key);  //降順
});

Alice => 95
Becky => 85
Cindy => 100
Daisy => 72
Eliza => 78

---

■KeyValuePair の List でのソート (IComparer)

　ICompare(Comparer) も使えるのでやってみよう。このような比較関数（クラス）は他の言語でもよくあるので、移植もしやすい。ちなみに以前書いた Java での連想配列(Map)でのソートと全く同じ構成となる。

●値(or キー)でのソート (KeyValuePair の List と IComparer)

using System;
using System.Collections.Generic;

public static void Main()
{
    Dictionary<string, int> dic = new Dictionary<string, int>() {
        { "Becky", 85 },
        { "Daisy", 72 },
        { "Alice", 95 },
        { "Eliza", 78 },
        { "Cindy", 100 },
    };

    List<KeyValuePair<string, int>> list = new List<KeyValuePair<string, int>>(dic);
    list.Sort(new MyComparer<string, int>());

    foreach (var v in list)
    {
        Console.WriteLine(v.Key + " => " + v.Value);
    }
}

//比較クラス(関数)
public class MyComparer<K,V> : IComparer<KeyValuePair<K,V>>
    where K : IComparable
    where V : IComparable
{
    public int Compare(KeyValuePair<K,V> a, KeyValuePair<K,V> b)  {
        return a.Value.CompareTo(b.Value);  //値 昇順
        //return b.Value.CompareTo(a.Value);  //値 降順
        //return a.Key.CompareTo(b.Key);  //キー 昇順
        //return b.Key.CompareTo(a.Key);  //キー 降順
    }
}

Daisy => 72
Eliza => 78
Becky => 85
Alice => 95
Cindy => 100

　上記の例では１つのクラスでまとめてしまったため、型パラメーターの制約を複数書いてしまっているが、値のみ(V)・キーのみ(K)とわかっているなら、制約はどちらかだけでも良い。同じようなことは delegate 版でもできると思うが、１つのクラスにまとめた利点としては、プロパティなどを追加して、いつでもソート方法を変更できる・同じソート方法を共有できること等にある。用途に合わせて使い分けるのも良いだろう。

---

■キーと値の２つの配列でのソート

　もう１つ、今回の連想配列のテーマからは少し外れるのだが、C# には「ソート対象となる１次元配列と、その項目に対応する別の１次元配列」をソートできる Array.Sort(Array, Array) がオーバーロードされている。まるで連想配列をソートするような感じになる。

●キーと値の２つの配列でのソート

using System;
using System.Collections.Generic;

public static void Main()
{
    string[] name = {"Alice", "Becky", "Cindy", "Daisy", "Eliza"};
    int[] value = {95, 85, 100, 72, 78};

    Array.Sort(value, name);  //昇順
    //Array.Sort(value, name, new RevComparer<int>());  //降順

    for (int i = 0; i < value.Length; i++)
    {
        Console.WriteLine(name[i] + " => " + value[i]);
    }
}

//逆順（降順）
public class RevComparer<T> : IComparer<T> where T : IComparable
{
    public int Compare(T a, T b)  {
        return b.CompareTo(a);    //降順
    }
}

Daisy => 72
Eliza => 78
Becky => 85
Alice => 95
Cindy => 100

　引数は Array.Sort(ソート対象の配列, 対応する配列, [IComparer]) となっている。

　ちなみに、コメントアウトされている「RevComparer」（逆順用 Comparer） で降順ソートすると結果は以下のようになる。

Cindy => 100
Alice => 95
Becky => 85
Eliza => 78
Daisy => 72

　ソートのキーとなる配列と値の配列（項目に対応する配列）は別々に作るので、型に自由が利くのが特徴だ。値の配列は何でも良いので、クラスや構造体の配列などをソートすることもできる。普段はクラスや構造体でデータを保持しておいて、ソートしたいときだけキーとなる配列を生成する等もできるだろう。

　Comparer（RevComparer）などもあらかじめ static で作っておけば（int など利用頻度が高い型を別に作っておけば）、毎回 new しなくて済むので実行速度がはやくなる。色々工夫してみると良いだろう。

（関連記事）
【C#】２次元配列（ジャグ配列・多次元配列）のソート
【C#】多次元配列とジャグ配列（２次元配列）のサイズ（長さ）、相互変換など