プログラミング

Javaの配列操作と検索

最終更新： 19/03/2025
1 分の読み

Javaにおける配列（Array）の検索と並べ替えは、プログラミングにおいて重要な操作です。配列は固定サイズのデータ構造であり、複数の同一型のデータを一度に格納するために使用されます。ここでは、Javaにおける配列の検索アルゴリズムと並べ替えアルゴリズムについて、完全かつ包括的に説明します。

1. 配列の検索アルゴリズム

配列内で特定の要素を探すことはよくある操作です。Javaにはこの操作を効率よく行うためのいくつかのアルゴリズムが存在します。代表的な検索アルゴリズムには、線形探索（Linear Search）と二分探索（Binary Search）があります。

関連記事

1.1 線形探索（Linear Search）

線形探索は、最も基本的な検索アルゴリズムです。配列の先頭から順番に要素を調べ、目的の値を見つける方法です。

java
public class LinearSearch {
    public static int linearSearch(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i;  // 要素が見つかればそのインデックスを返す
            }
        }
        return -1;  // 要素が見つからなければ-1を返す
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 6, 7};
        int target = 8;
        int index = linearSearch(arr, target);
        System.out.println("ターゲットのインデックス: " + index);
    }
}

このコードでは、配列内の全ての要素を順番にチェックし、目的の値が見つかるとそのインデックスを返します。もし値が見つからなければ、-1が返されます。

1.2 二分探索（Binary Search）

二分探索は、配列が事前にソートされている場合に非常に効率的な検索方法です。配列の中央の要素を比較して、目的の値がその値より大きいか小さいかによって探索範囲を半分に絞ります。この操作を繰り返すことで、目的の要素を効率的に見つけることができます。

java
import java.util.Arrays;

public class BinarySearch {
    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == target) {
                return mid;  // 要素が見つかればそのインデックスを返す
            }
            if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;  // 要素が見つからなければ-1を返す
    }

    public static void main(String[] args) {
        int[] arr = {3, 5, 6, 7, 8};
        int target = 7;
        int index = binarySearch(arr, target);
        System.out.println("ターゲットのインデックス: " + index);
    }
}

このアルゴリズムは、線形探索よりも遥かに効率的です。配列がソートされている場合、探索時間はO(log n)となります。最悪の場合でも、配列サイズが10倍になっても探索時間はわずかに増加するだけです。

2. 配列の並べ替えアルゴリズム

配列を並べ替えるためには、様々なアルゴリズムを使用することができます。ここでは、代表的な並べ替えアルゴリズムをいくつか紹介します。

2.1 バブルソート（Bubble Sort）

バブルソートは、隣接する要素を比較して順番を入れ替えながら並べ替えていくアルゴリズムです。アルゴリズムはシンプルですが、最悪の場合の時間計算量はO(n^2)となるため、大きなデータセットには向いていません。

java
public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 隣接する要素を入れ替える
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 6, 7};
        bubbleSort(arr);
        System.out.println("並べ替え後の配列: " + Arrays.toString(arr));
    }
}

バブルソートは、最も単純な並べ替えアルゴリズムですが、実際の用途ではあまり効率的ではありません。しかし、理解しやすく、教育的な目的には適しています。

2.2 クイックソート（Quick Sort）

クイックソートは、高速な並べ替えアルゴリズムで、平均的な時間計算量はO(n log n)です。クイックソートは分割統治法を使用して、配列を再帰的に分割していきます。最も効率的な並べ替えアルゴリズムの一つとされています。

java
public class QuickSort {
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = partition(arr, low, high);
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }

    public static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = (low - 1);
        for (int j = low; j < high; j++) {
            if (arr[j] <= pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 6, 7};
        quickSort(arr, 0, arr.length - 1);
        System.out.println("並べ替え後の配列: " + Arrays.toString(arr));
    }
}

クイックソートは非常に効率的であり、大規模なデータセットに対しても高速に動作します。実際のアプリケーションでもよく使われるアルゴリズムです。

2.3 マージソート（Merge Sort）

マージソートは、分割統治法に基づく並べ替えアルゴリズムで、常にO(n log n)の時間計算量を持ちます。特に安定しており、大規模なデータの並べ替えに適しています。

java
public class MergeSort {
    public static void mergeSort(int[] arr, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);
            merge(arr, left, mid, right);
        }
    }

    public static void merge(int[] arr, int left, int mid, int right) {
        int n1 = mid - left + 1;
        int n2 = right - mid;
        int[] L = new int[n1];
        int[] R = new int[n2];

        for (int i = 0; i < n1; i++) {
            L[i] = arr[left + i];
        }
        for (int j = 0; j < n2; j++) {
            R[j] = arr[mid + 1 + j];
        }

        int i = 0, j = 0;
        int k = left;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }

        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 6, 7};
        mergeSort(arr, 0, arr.length - 1);
        System.out.println("並べ替え後の配列: " + Arrays.toString(arr));
    }
}

3. 結論

Javaにおける配列の検索と並べ替えは、プログラムの効率性や性能に大きな影響を与えます。線形探索や二分探索、バブルソートやクイックソート、マージソートなどのアルゴリズムは、用途やデータの特性に応じて使い分けることが大切です。適切なアルゴリズムを選択することで、プログラムの動作を大きく改善することができます。

最終更新： 19/03/2025
1 分の読み
Back to top button