配列&コレクション

[C#] Sortメソッドの使い方 – 配列やリストをソートする

2025-01-18更新日: 2025-01-18

C#のSortメソッドは、配列やリストの要素を昇順に並べ替えるために使用されます。

配列の場合、Array.Sort()を使用し、リストの場合はList<T>.Sort()を使用します。

デフォルトでは、要素は昇順にソートされますが、カスタムの比較ロジックを指定することも可能です。

例えば、Comparison<T>デリゲートやIComparer<T>インターフェースを使用して、独自のソート順序を定義できます。

目次から探す

Sortメソッドとは
配列のソート
リストのソート
カスタムソートの実装
ソートのパフォーマンス
応用例
まとめ

Sortメソッドとは

C#のSortメソッドは、配列やリストの要素を特定の順序で並べ替えるための便利な機能です。

主に昇順(小さいものから大きいものへ)や降順(大きいものから小さいものへ)でのソートが可能で、数値や文字列、カスタムオブジェクトなど、さまざまなデータ型に対応しています。

Sortメソッドは、内部的に効率的なソートアルゴリズムを使用しており、大規模なデータセットでも迅速に処理を行うことができます。

特に、配列やリストの要素を簡単に並べ替えたい場合に非常に役立ちます。

C#では、ArrayクラスやListクラスにそれぞれSortメソッドが用意されており、使い方もシンプルです。

これにより、プログラマーはデータの整理や検索を効率的に行うことができます。

配列のソート

Array.Sortメソッドの使い方

C#では、配列をソートするためにArray.Sortメソッドを使用します。

このメソッドは、配列の要素を昇順に並べ替えます。

基本的な使い方は非常にシンプルで、配列を引数として渡すだけです。

using System;
class Program
{
    static void Main()
    {
        int[] numbers = { 5, 3, 8, 1, 4 };
        Array.Sort(numbers); // 配列を昇順にソート
        foreach (var number in numbers)
        {
            Console.WriteLine(number); // ソートされた配列を出力
        }
    }
}

数値配列のソート

数値配列をソートする場合も、Array.Sortメソッドを使用します。

以下の例では、整数の配列を昇順にソートしています。

using System;
class Program
{
    static void Main()
    {
        int[] numbers = { 10, 2, 8, 6, 4 };
        Array.Sort(numbers); // 数値配列をソート
        foreach (var number in numbers)
        {
            Console.WriteLine(number); // ソートされた配列を出力
        }
    }
}

文字列配列のソート

文字列の配列も同様にArray.Sortメソッドを使ってソートできます。

以下の例では、文字列の配列を昇順にソートしています。

using System;
class Program
{
    static void Main()
    {
        string[] fruits = { "Banana", "Apple", "Cherry", "Mango" };
        Array.Sort(fruits); // 文字列配列をソート
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit); // ソートされた配列を出力
        }
    }
}

Apple
Banana
Cherry
Mango

カスタムオブジェクト配列のソート

カスタムオブジェクトの配列をソートする場合、IComparableインターフェースを実装する必要があります。

以下の例では、Personクラスを作成し、年齢でソートしています。

using System;
class Person : IComparable<Person>
{
    public string Name { get; set; }
    public int Age { get; set; }
    public int CompareTo(Person other)
    {
        return this.Age.CompareTo(other.Age); // 年齢で比較
    }
}
class Program
{
    static void Main()
    {
        Person[] people = {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };
        Array.Sort(people); // カスタムオブジェクト配列をソート
        foreach (var person in people)
        {
            Console.WriteLine($"{person.Name}: {person.Age}"); // ソートされた配列を出力
        }
    }
}

Bob: 25
Alice: 30
Charlie: 35

降順でソートする方法

降順でソートするには、Array.Sortメソッドを使用した後にArray.Reverseメソッドを呼び出す方法があります。

以下の例では、数値配列を降順にソートしています。

using System;
class Program
{
    static void Main()
    {
        int[] numbers = { 5, 3, 8, 1, 4 };
        Array.Sort(numbers); // 昇順にソート
        Array.Reverse(numbers); // 降順に反転
        foreach (var number in numbers)
        {
            Console.WriteLine(number); // ソートされた配列を出力
        }
    }
}

部分的にソートする方法

配列の一部だけをソートする場合、Array.Sortメソッドのオーバーロードを使用します。

開始インデックスとソートする要素数を指定できます。

using System;
class Program
{
    static void Main()
    {
        int[] numbers = { 5, 3, 8, 1, 4 };
        Array.Sort(numbers, 1, 3); // インデックス1から3つの要素をソート
        foreach (var number in numbers)
        {
            Console.WriteLine(number); // ソートされた配列を出力
        }
    }
}

このように、C#のArray.Sortメソッドを使うことで、配列を簡単にソートすることができます。

リストのソート

List<T>.Sortメソッドの使い方

C#のリストをソートするためには、List<T>.Sortメソッドを使用します。

このメソッドは、リストの要素を昇順に並べ替えます。

使い方は非常にシンプルで、リストのインスタンスに対して呼び出すだけです。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 3, 8, 1, 4 };
        numbers.Sort(); // リストを昇順にソート
        foreach (var number in numbers)
        {
            Console.WriteLine(number); // ソートされたリストを出力
        }
    }
}

数値リストのソート

数値のリストをソートする場合も、List<T>.Sortメソッドを使用します。

以下の例では、整数のリストを昇順にソートしています。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 10, 2, 8, 6, 4 };
        numbers.Sort(); // 数値リストをソート
        foreach (var number in numbers)
        {
            Console.WriteLine(number); // ソートされたリストを出力
        }
    }
}

文字列リストのソート

文字列のリストも同様にList<T>.Sortメソッドを使ってソートできます。

以下の例では、文字列のリストを昇順にソートしています。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        List<string> fruits = new List<string> { "Banana", "Apple", "Cherry", "Mango" };
        fruits.Sort(); // 文字列リストをソート
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit); // ソートされたリストを出力
        }
    }
}

Apple
Banana
Cherry
Mango

カスタムオブジェクトリストのソート

カスタムオブジェクトのリストをソートする場合、IComparableインターフェースを実装する必要があります。

以下の例では、Personクラスを作成し、年齢でソートしています。

using System;
using System.Collections.Generic;
class Person : IComparable<Person>
{
    public string Name { get; set; }
    public int Age { get; set; }
    public int CompareTo(Person other)
    {
        return this.Age.CompareTo(other.Age); // 年齢で比較
    }
}
class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };
        people.Sort(); // カスタムオブジェクトリストをソート
        foreach (var person in people)
        {
            Console.WriteLine($"{person.Name}: {person.Age}"); // ソートされたリストを出力
        }
    }
}

Bob: 25
Alice: 30
Charlie: 35

降順でソートする方法

降順でソートするには、List<T>.Sortメソッドを使用した後にList<T>.Reverseメソッドを呼び出す方法があります。

以下の例では、数値リストを降順にソートしています。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 3, 8, 1, 4 };
        numbers.Sort(); // 昇順にソート
        numbers.Reverse(); // 降順に反転
        foreach (var number in numbers)
        {
            Console.WriteLine(number); // ソートされたリストを出力
        }
    }
}

部分的にソートする方法

リストの一部だけをソートする場合、List<T>.Sortメソッドのオーバーロードを使用することはできませんが、LINQを使用して部分的にソートすることができます。

以下の例では、リストの一部をソートしています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 3, 8, 1, 4 };
        var sortedPart = numbers.Skip(1).Take(3).OrderBy(n => n).ToList(); // インデックス1から3つの要素をソート
        for (int i = 0; i < numbers.Count; i++)
        {
            if (i >= 1 && i < 4)
            {
                Console.WriteLine(sortedPart[i - 1]); // ソートされた部分を出力
            }
            else
            {
                Console.WriteLine(numbers[i]); // その他の要素を出力
            }
        }
    }
}

このように、C#のList<T>.Sortメソッドを使うことで、リストを簡単にソートすることができます。

カスタムソートの実装

Comparison<T>デリゲートを使ったカスタムソート

C#では、Comparison<T>デリゲートを使用してカスタムソートを実装できます。

このデリゲートは、2つのオブジェクトを比較するメソッドを指定するために使用されます。

以下の例では、Personクラスのリストを年齢でソートしています。

using System;
using System.Collections.Generic;
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };
        // Comparisonデリゲートを使用して年齢でソート
        people.Sort((x, y) => x.Age.CompareTo(y.Age));
        foreach (var person in people)
        {
            Console.WriteLine($"{person.Name}: {person.Age}"); // ソートされたリストを出力
        }
    }
}

Bob: 25
Alice: 30
Charlie: 35

IComparer<T>インターフェースを使ったカスタムソート

IComparer<T>インターフェースを実装することで、より柔軟なカスタムソートを行うことができます。

このインターフェースを実装したクラスを作成し、Sortメソッドに渡すことで、特定の条件でソートできます。

using System;
using System.Collections.Generic;
class Person : IComparer<Person>
{
    public string Name { get; set; }
    public int Age { get; set; }
    public int Compare(Person x, Person y)
    {
        return x.Name.CompareTo(y.Name); // 名前で比較
    }
}
class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };
        people.Sort(new Person()); // IComparerを使用して名前でソート
        foreach (var person in people)
        {
            Console.WriteLine($"{person.Name}: {person.Age}"); // ソートされたリストを出力
        }
    }
}

Alice: 30
Bob: 25
Charlie: 35

複数条件でのソート

複数の条件でソートする場合、IComparer<T>を使用して、複数の比較を行うことができます。

以下の例では、年齢でソートし、年齢が同じ場合は名前でソートしています。

using System;
using System.Collections.Generic;
class Person : IComparer<Person>
{
    public string Name { get; set; }
    public int Age { get; set; }
    public int Compare(Person x, Person y)
    {
        int ageComparison = x.Age.CompareTo(y.Age);
        if (ageComparison == 0)
        {
            return x.Name.CompareTo(y.Name); // 年齢が同じ場合は名前で比較
        }
        return ageComparison;
    }
}
class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 30 }
        };
        people.Sort(new Person()); // 複数条件でソート
        foreach (var person in people)
        {
            Console.WriteLine($"{person.Name}: {person.Age}"); // ソートされたリストを出力
        }
    }
}

Bob: 25
Alice: 30
Charlie: 30

ソートの安定性について

ソートの安定性とは、同じキーを持つ要素の相対的な順序が保持されることを指します。

C#のArray.SortおよびList<T>.Sortメソッドは、安定なソートを提供します。

つまり、同じ値を持つ要素が元の順序を維持します。

例えば、以下のように年齢が同じ人物がいる場合、元のリストの順序が保持されます。

using System;
using System.Collections.Generic;
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Charlie", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };
        people.Sort((x, y) => x.Age.CompareTo(y.Age)); // 年齢でソート
        foreach (var person in people)
        {
            Console.WriteLine($"{person.Name}: {person.Age}"); // ソートされたリストを出力
        }
    }
}

Bob: 25
Charlie: 30
Alice: 30

このように、C#のソートメソッドは安定性を持っているため、同じキーを持つ要素の順序が保持されることが保証されています。

ソートのパフォーマンス

Sortメソッドの計算量

C#のSortメソッドは、内部的にクイックソートアルゴリズムを使用しています。

クイックソートは平均的な計算量が \(O(n \log n)\) であり、最悪の場合は \(O(n^2)\) となります。

ただし、C#の実装では、最悪のケースを避けるために、特定の条件下でヒープソートに切り替えることがあります。

これにより、最悪の場合でも \(O(n \log n)\) の計算量が保証されます。

大規模データのソート時の注意点

大規模データをソートする際には、いくつかの注意点があります。

メモリ使用量: 大きな配列やリストをソートする場合、メモリの使用量が増加します。

特に、ソートアルゴリズムによっては追加のメモリを必要とすることがあります。

データの特性: データがほぼソートされている場合、クイックソートは非常に効率的ですが、逆に完全に逆順の場合はパフォーマンスが低下する可能性があります。
スレッドセーフ: 複数のスレッドから同時にソートを行う場合、スレッドセーフでないため、注意が必要です。

ソートアルゴリズムの選択肢

C#では、Sortメソッド以外にもさまざまなソートアルゴリズムを選択することができます。

以下は一般的なソートアルゴリズムのいくつかです。

アルゴリズム名	計算量 (平均)	計算量 (最悪)	特徴
クイックソート	\(O(n \log n)\)	\(O(n^2)\)	高速で、平均的に効率的
マージソート	\(O(n \log n)\)	\(O(n \log n)\)	安定なソート、追加メモリが必要
ヒープソート	\(O(n \log n)\)	\(O(n \log n)\)	安定性はないが、メモリ使用量が少ない
バブルソート	\(O(n^2)\)	\(O(n^2)\)	簡単だが、効率が悪い

パフォーマンスを向上させるためのヒント

ソートのパフォーマンスを向上させるためのいくつかのヒントを以下に示します。

データの前処理: ソートする前にデータを整理し、不要な要素を削除することで、ソートの負荷を軽減できます。
適切なアルゴリズムの選択: データの特性に応じて、適切なソートアルゴリズムを選択することが重要です。

例えば、データがほぼソートされている場合は、挿入ソートが効果的です。

並列処理の活用: 大規模データを扱う場合、並列処理を利用してソートを行うことで、パフォーマンスを向上させることができます。

C#では、Parallel.Forを使用して並列処理を実装できます。

メモリ管理: 大きなデータセットを扱う場合、メモリの使用量を最小限に抑えるために、必要なデータのみを保持するように心がけましょう。

これらのヒントを活用することで、C#におけるソートのパフォーマンスを向上させることができます。

応用例

ソート済みデータを効率的に検索する

ソート済みのデータに対しては、効率的な検索アルゴリズムである二分探索を使用することができます。

C#では、Array.BinarySearchメソッドやList<T>.BinarySearchメソッドを利用して、ソートされた配列やリストから特定の要素を迅速に検索できます。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        int[] sortedNumbers = { 1, 3, 4, 5, 8 };
        int index = Array.BinarySearch(sortedNumbers, 4); // 4のインデックスを検索
        if (index >= 0)
        {
            Console.WriteLine($"4はインデックス{index}に存在します。");
        }
        else
        {
            Console.WriteLine("4は存在しません。");
        }
    }
}

4はインデックス2に存在します。

LINQを使ったソート

LINQ(Language Integrated Query)を使用すると、コレクションを簡単にソートできます。

OrderByメソッドを使って、特定のプロパティに基づいてオブジェクトのリストをソートすることができます。

using System;
using System.Collections.Generic;
using System.Linq;
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };
        var sortedPeople = people.OrderBy(p => p.Age).ToList(); // 年齢でソート
        foreach (var person in sortedPeople)
        {
            Console.WriteLine($"{person.Name}: {person.Age}"); // ソートされたリストを出力
        }
    }
}

Bob: 25
Alice: 30
Charlie: 35

ソート結果を新しい配列やリストに保存する

ソートした結果を新しい配列やリストに保存することも可能です。

ToArrayメソッドやToListメソッドを使用して、ソート結果を新しいコレクションに格納できます。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        int[] numbers = { 5, 3, 8, 1, 4 };
        var sortedNumbers = numbers.OrderBy(n => n).ToArray(); // ソートして新しい配列に保存
        foreach (var number in sortedNumbers)
        {
            Console.WriteLine(number); // ソートされた配列を出力
        }
    }
}

ソートとフィルタリングの組み合わせ

ソートとフィルタリングを組み合わせることで、特定の条件に合致するデータを効率的に取得できます。

LINQを使用して、条件に基づいてフィルタリングした後にソートすることができます。

using System;
using System.Collections.Generic;
using System.Linq;
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 },
            new Person { Name = "David", Age = 20 }
        };
        var filteredAndSortedPeople = people
            .Where(p => p.Age >= 25) // 年齢が25以上の人をフィルタリング
            .OrderBy(p => p.Age) // 年齢でソート
            .ToList();
        foreach (var person in filteredAndSortedPeople)
        {
            Console.WriteLine($"{person.Name}: {person.Age}"); // フィルタリングされたソート結果を出力
        }
    }
}

Bob: 25
Alice: 30
Charlie: 35

ソートと並列処理の組み合わせ

大規模なデータセットを扱う場合、並列処理を利用してソートを行うことでパフォーマンスを向上させることができます。

C#のParallelクラスを使用して、データを分割し、各部分を並列にソートすることができます。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
class Program
{
    static void Main()
    {
        List<int> numbers = Enumerable.Range(1, 1000000).OrderBy(n => Guid.NewGuid()).ToList(); // ランダムな数値リストを生成
        // 並列処理を使用してソート
        var sortedNumbers = numbers.AsParallel().OrderBy(n => n).ToList();
        Console.WriteLine($"最小値: {sortedNumbers.First()}"); // ソートされたリストの最小値を出力
        Console.WriteLine($"最大値: {sortedNumbers.Last()}"); // ソートされたリストの最大値を出力
    }
}