コンテンツにスキップ
日本語版のレビュアーを募集しています。詳しくは こちら をご覧ください。

# 11.2 選択ソート

選択ソート（selection sort）の仕組みは非常に単純です。ループを開始し、各ラウンドで未ソート区間から最小の要素を選び、整列済み区間の末尾に配置します。

配列の長さを \(n\) とすると、選択ソートの手順は次の図のようになります。

1. 初期状態では、すべての要素が未ソートであり、未ソートな（インデックス）区間は \([0, n-1]\) です。
2. 区間 \([0, n-1]\) 内の最小要素を選び、インデックス \(0\) の要素と交換します。これにより、配列の先頭 1 要素が整列済みになります。
3. 区間 \([1, n-1]\) 内の最小要素を選び、インデックス \(1\) の要素と交換します。これにより、配列の先頭 2 要素が整列済みになります。
4. これを繰り返します。\(n - 1\) 回の選択と交換を経ると、配列の先頭 \(n - 1\) 要素が整列済みになります。
5. 残った 1 つの要素は必ず最大要素なので、ソートは不要です。これで配列のソートは完了します。

<1><2><3><4><5><6><7><8><9><10><11>

図 11-2 選択ソートの手順

コードでは、\(k\) を用いて未ソート区間内の最小要素を記録します。

Python C++Java C#Go Swift JS TS Dart Rust C Kotlin Ruby
selection_sort.py

    def selection_sort(nums: list[int]):
        """選択ソート"""
        n = len(nums)
        # 外側ループ：未整列区間は [i, n-1]
        for i in range(n - 1):
            # 内側のループ：未ソート区間の最小要素を見つける
            k = i
            for j in range(i + 1, n):
                if nums[j] < nums[k]:
                    k = j  # 最小要素のインデックスを記録
            # その最小要素を未整列区間の先頭要素と交換する
            nums[i], nums[k] = nums[k], nums[i]

selection_sort.cpp

    /* 選択ソート */
    void selectionSort(vector<int> &nums) {
        int n = nums.size();
        // 外側ループ：未整列区間は [i, n-1]
        for (int i = 0; i < n - 1; i++) {
            // 内側のループ：未ソート区間の最小要素を見つける
            int k = i;
            for (int j = i + 1; j < n; j++) {
                if (nums[j] < nums[k])
                    k = j; // 最小要素のインデックスを記録
            }
            // その最小要素を未整列区間の先頭要素と交換する
            swap(nums[i], nums[k]);
        }
    }

selection_sort.java

    /* 選択ソート */
    void selectionSort(int[] nums) {
        int n = nums.length;
        // 外側ループ：未整列区間は [i, n-1]
        for (int i = 0; i < n - 1; i++) {
            // 内側のループ：未ソート区間の最小要素を見つける
            int k = i;
            for (int j = i + 1; j < n; j++) {
                if (nums[j] < nums[k])
                    k = j; // 最小要素のインデックスを記録
            }
            // その最小要素を未整列区間の先頭要素と交換する
            int temp = nums[i];
            nums[i] = nums[k];
            nums[k] = temp;
        }
    }

selection_sort.cs

    /* 選択ソート */
    void SelectionSort(int[] nums) {
        int n = nums.Length;
        // 外側ループ：未整列区間は [i, n-1]
        for (int i = 0; i < n - 1; i++) {
            // 内側のループ：未ソート区間の最小要素を見つける
            int k = i;
            for (int j = i + 1; j < n; j++) {
                if (nums[j] < nums[k])
                    k = j; // 最小要素のインデックスを記録
            }
            // その最小要素を未整列区間の先頭要素と交換する
            (nums[k], nums[i]) = (nums[i], nums[k]);
        }
    }

selection_sort.go

    /* 選択ソート */
    func selectionSort(nums []int) {
        n := len(nums)
        // 外側ループ：未整列区間は [i, n-1]
        for i := 0; i < n-1; i++ {
            // 内側のループ：未ソート区間の最小要素を見つける
            k := i
            for j := i + 1; j < n; j++ {
                if nums[j] < nums[k] {
                    // 最小要素のインデックスを記録
                    k = j
                }
            }
            // その最小要素を未整列区間の先頭要素と交換する
            nums[i], nums[k] = nums[k], nums[i]

        }
    }

selection_sort.swift

    /* 選択ソート */
    func selectionSort(nums: inout [Int]) {
        // 外側ループ：未整列区間は [i, n-1]
        for i in nums.indices.dropLast() {
            // 内側のループ：未ソート区間の最小要素を見つける
            var k = i
            for j in nums.indices.dropFirst(i + 1) {
                if nums[j] < nums[k] {
                    k = j // 最小要素のインデックスを記録
                }
            }
            // その最小要素を未整列区間の先頭要素と交換する
            nums.swapAt(i, k)
        }
    }

selection_sort.js

    /* 選択ソート */
    function selectionSort(nums) {
        let n = nums.length;
        // 外側ループ：未整列区間は [i, n-1]
        for (let i = 0; i < n - 1; i++) {
            // 内側のループ：未ソート区間の最小要素を見つける
            let k = i;
            for (let j = i + 1; j < n; j++) {
                if (nums[j] < nums[k]) {
                    k = j; // 最小要素のインデックスを記録
                }
            }
            // その最小要素を未整列区間の先頭要素と交換する
            [nums[i], nums[k]] = [nums[k], nums[i]];
        }
    }

selection_sort.ts

    /* 選択ソート */
    function selectionSort(nums: number[]): void {
        let n = nums.length;
        // 外側ループ：未整列区間は [i, n-1]
        for (let i = 0; i < n - 1; i++) {
            // 内側のループ：未ソート区間の最小要素を見つける
            let k = i;
            for (let j = i + 1; j < n; j++) {
                if (nums[j] < nums[k]) {
                    k = j; // 最小要素のインデックスを記録
                }
            }
            // その最小要素を未整列区間の先頭要素と交換する
            [nums[i], nums[k]] = [nums[k], nums[i]];
        }
    }

selection_sort.dart

    /* 選択ソート */
    void selectionSort(List<int> nums) {
      int n = nums.length;
      // 外側ループ：未整列区間は [i, n-1]
      for (int i = 0; i < n - 1; i++) {
        // 内側のループ：未ソート区間の最小要素を見つける
        int k = i;
        for (int j = i + 1; j < n; j++) {
          if (nums[j] < nums[k]) k = j; // 最小要素のインデックスを記録
        }
        // その最小要素を未整列区間の先頭要素と交換する
        int temp = nums[i];
        nums[i] = nums[k];
        nums[k] = temp;
      }
    }

selection_sort.rs

    /* 選択ソート */
    fn selection_sort(nums: &mut [i32]) {
        if nums.is_empty() {
            return;
        }
        let n = nums.len();
        // 外側ループ：未整列区間は [i, n-1]
        for i in 0..n - 1 {
            // 内側のループ：未ソート区間の最小要素を見つける
            let mut k = i;
            for j in i + 1..n {
                if nums[j] < nums[k] {
                    k = j; // 最小要素のインデックスを記録
                }
            }
            // その最小要素を未整列区間の先頭要素と交換する
            nums.swap(i, k);
        }
    }

selection_sort.c

    /* 選択ソート */
    void selectionSort(int nums[], int n) {
        // 外側ループ：未整列区間は [i, n-1]
        for (int i = 0; i < n - 1; i++) {
            // 内側のループ：未ソート区間の最小要素を見つける
            int k = i;
            for (int j = i + 1; j < n; j++) {
                if (nums[j] < nums[k])
                    k = j; // 最小要素のインデックスを記録
            }
            // その最小要素を未整列区間の先頭要素と交換する
            int temp = nums[i];
            nums[i] = nums[k];
            nums[k] = temp;
        }
    }

selection_sort.kt

    /* 選択ソート */
    fun selectionSort(nums: IntArray) {
        val n = nums.size
        // 外側ループ：未整列区間は [i, n-1]
        for (i in 0..<n - 1) {
            var k = i
            // 内側のループ：未ソート区間の最小要素を見つける
            for (j in i + 1..<n) {
                if (nums[j] < nums[k])
                    k = j // 最小要素のインデックスを記録
            }
            // その最小要素を未整列区間の先頭要素と交換する
            val temp = nums[i]
            nums[i] = nums[k]
            nums[k] = temp
        }
    }

selection_sort.rb

    ### 選択ソート ###
    def selection_sort(nums)
      n = nums.length
      # 外側ループ：未整列区間は [i, n-1]
      for i in 0...(n - 1)
        # 内側のループ：未ソート区間の最小要素を見つける
        k = i
        for j in (i + 1)...n
          if nums[j] < nums[k]
            k = j # 最小要素のインデックスを記録
          end
        end
        # その最小要素を未整列区間の先頭要素と交換する
        nums[i], nums[k] = nums[k], nums[i]
      end
    end

コードの可視化

全画面で見る >

## 11.2.1 アルゴリズムの特徴

- 時間計算量は \(O(n^2)\)、非適応ソート：外側のループは合計 \(n - 1\) 回です。内側のループは最初のラウンドで \(n - 1\) 回、最後のラウンドで \(1\) 回実行されます。各ラウンドの実行回数はそれぞれ \(n - 1\)、\(n - 2\)、\(\dots\)、\(2\)、\(1\) であり、総和は \(\frac{n(n - 1)}{2}\) です。
- 空間計算量は \(O(1)\)、インプレースソート：ポインタ \(i\) と \(j\) は定数サイズの追加領域しか使用しません。
- 不安定ソート：次の図のように、要素 `nums[i]` がそれと等しい要素の右側へ交換され、両者の相対的な順序が変わる可能性があります。

図 11-3 選択ソートの不安定な例

##### ご意見、ご質問、ご提案があればぜひコメントしてください