では 7種類のソート（バブル、選択、挿入、マージ、クイック、ヒープ、シェル） を 同じ配列で比較できる Java 完全コード を作ります。
- 配列はコピーして各ソートに渡す
- 結果をまとめて表示
- 初心者向けにコメント付き
7種類のソート比較 Java 完全コード
import java.util.Arrays;
public class SortComparison7 {
public static void main(String[] args) {
int[] original = {7, 2, 9, 4, 3, 8, 1, 6};
System.out.println("元の配列: " + Arrays.toString(original));
// -------------------
// バブルソート
// -------------------
int[] bubbleArr = Arrays.copyOf(original, original.length);
bubbleSort(bubbleArr);
System.out.println("バブルソート: " + Arrays.toString(bubbleArr));
// -------------------
// 選択ソート
// -------------------
int[] selectionArr = Arrays.copyOf(original, original.length);
selectionSort(selectionArr);
System.out.println("選択ソート: " + Arrays.toString(selectionArr));
// -------------------
// 挿入ソート
// -------------------
int[] insertionArr = Arrays.copyOf(original, original.length);
insertionSort(insertionArr);
System.out.println("挿入ソート: " + Arrays.toString(insertionArr));
// -------------------
// マージソート
// -------------------
int[] mergeArr = Arrays.copyOf(original, original.length);
mergeSort(mergeArr, 0, mergeArr.length - 1);
System.out.println("マージソート: " + Arrays.toString(mergeArr));
// -------------------
// クイックソート
// -------------------
int[] quickArr = Arrays.copyOf(original, original.length);
quickSort(quickArr, 0, quickArr.length - 1);
System.out.println("クイックソート: " + Arrays.toString(quickArr));
// -------------------
// ヒープソート
// -------------------
int[] heapArr = Arrays.copyOf(original, original.length);
heapSort(heapArr);
System.out.println("ヒープソート: " + Arrays.toString(heapArr));
// -------------------
// シェルソート
// -------------------
int[] shellArr = Arrays.copyOf(original, original.length);
shellSort(shellArr);
System.out.println("シェルソート: " + Arrays.toString(shellArr));
}
// =======================
// バブルソート
// =======================
public static void bubbleSort(int[] arr) {
int n = arr.length;
boolean swapped;
for (int i = 0; i < n - 1; i++) {
swapped = false;
for (int j = 0; j < n - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
swapped = true;
}
}
if (!swapped) break;
}
}
// =======================
// 選択ソート
// =======================
public static void selectionSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) minIndex = j;
}
int tmp = arr[i]; arr[i] = arr[minIndex]; arr[minIndex] = tmp;
}
}
// =======================
// 挿入ソート
// =======================
public static void insertionSort(int[] arr) {
int n = arr.length;
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
// =======================
// マージソート
// =======================
public static void mergeSort(int[] arr, int left, int right) {
if (left >= right) return;
int mid = (left + right) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
private static void merge(int[] arr, int left, int mid, int right) {
int[] tmp = new int[right - left + 1];
int i = left, j = mid + 1, k = 0;
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) tmp[k++] = arr[i++];
else tmp[k++] = arr[j++];
}
while (i <= mid) tmp[k++] = arr[i++];
while (j <= right) tmp[k++] = arr[j++];
for (int t = 0; t < tmp.length; t++) arr[left + t] = tmp[t];
}
// =======================
// クイックソート
// =======================
public static void quickSort(int[] arr, int left, int right) {
if (left >= right) return;
int pivot = arr[(left + right) / 2];
int index = partition(arr, left, right, pivot);
quickSort(arr, left, index - 1);
quickSort(arr, index, right);
}
private static int partition(int[] arr, int left, int right, int pivot) {
while (left <= right) {
while (arr[left] < pivot) left++;
while (arr[right] > pivot) right--;
if (left <= right) {
int tmp = arr[left]; arr[left] = arr[right]; arr[right] = tmp;
left++; right--;
}
}
return left;
}
// =======================
// ヒープソート
// =======================
public static void heapSort(int[] arr) {
int n = arr.length;
for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i);
for (int i = n - 1; i >= 0; i--) {
int tmp = arr[0]; arr[0] = arr[i]; arr[i] = tmp;
heapify(arr, i, 0);
}
}
private static void heapify(int[] arr, int size, int i) {
int largest = i;
int left = 2 * i + 1, right = 2 * i + 2;
if (left < size && arr[left] > arr[largest]) largest = left;
if (right < size && arr[right] > arr[largest]) largest = right;
if (largest != i) {
int tmp = arr[i]; arr[i] = arr[largest]; arr[largest] = tmp;
heapify(arr, size, largest);
}
}
// =======================
// シェルソート
// =======================
public static void shellSort(int[] arr) {
int n = arr.length;
for (int gap = n / 2; gap > 0; gap /= 2) {
for (int i = gap; i < n; i++) {
int temp = arr[i];
int j = i;
while (j >= gap && arr[j - gap] > temp) {
arr[j] = arr[j - gap];
j -= gap;
}
arr[j] = temp;
}
}
}
}
実行例（出力）
元の配列: [7, 2, 9, 4, 3, 8, 1, 6]
バブルソート: [1, 2, 3, 4, 6, 7, 8, 9]
選択ソート: [1, 2, 3, 4, 6, 7, 8, 9]
挿入ソート: [1, 2, 3, 4, 6, 7, 8, 9]
マージソート: [1, 2, 3, 4, 6, 7, 8, 9]
クイックソート: [1, 2, 3, 4, 6, 7, 8, 9]
ヒープソート: [1, 2, 3, 4, 6, 7, 8, 9]
シェルソート: [1, 2, 3, 4, 6, 7, 8, 9]
💡 ポイント
- 各ソートを同じ配列で比較可能
- コピーして渡すことで元配列を保持
- 初心者でもそれぞれの違いを確認しやすい