では 7種類のソート（バブル、選択、挿入、マージ、クイック、ヒープ、シェル） の 処理過程をステップごとに表示して可視化する Java コード を作ります。
- 配列が変化するたびに出力
- 初心者でもソートの動きをイメージしやすい
- コメント付きで理解しやすく
7種類ソートのステップ可視化 Java コード
import java.util.Arrays;
public class SortVisualization7 {
public static void main(String[] args) {
int[] original = {7, 2, 9, 4, 3, 8, 1, 6};
System.out.println("元の配列: " + Arrays.toString(original));
System.out.println();
runAndVisualize("バブルソート", original, SortVisualization7::bubbleSort);
runAndVisualize("選択ソート", original, SortVisualization7::selectionSort);
runAndVisualize("挿入ソート", original, SortVisualization7::insertionSort);
runAndVisualize("マージソート", original, arr -> mergeSort(arr, 0, arr.length - 1));
runAndVisualize("クイックソート", original, arr -> quickSort(arr, 0, arr.length - 1));
runAndVisualize("ヒープソート", original, SortVisualization7::heapSort);
runAndVisualize("シェルソート", original, SortVisualization7::shellSort);
}
// --------------------------
// 配列をコピーしてソート＆可視化
// --------------------------
private static void runAndVisualize(String name, int[] original, Sorter sorter) {
int[] arr = Arrays.copyOf(original, original.length);
System.out.println("==== " + name + " ====");
sorter.sort(arr);
System.out.println("最終結果: " + Arrays.toString(arr));
System.out.println();
}
@FunctionalInterface
interface Sorter { void sort(int[] arr); }
// =======================
// バブルソート
// =======================
public static void bubbleSort(int[] arr) {
int n = arr.length;
boolean swapped;
for (int i = 0; i < n - 1; i++) {
swapped = false;
System.out.println("パス " + (i+1) + " 開始: " + Arrays.toString(arr));
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;
System.out.println(" swap " + arr[j+1] + " と " + arr[j] + ": " + Arrays.toString(arr));
}
}
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;
}
if (i != minIndex) {
int tmp = arr[i]; arr[i] = arr[minIndex]; arr[minIndex] = tmp;
System.out.println("ステップ " + (i+1) + ": " + Arrays.toString(arr));
}
}
}
// =======================
// 挿入ソート
// =======================
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;
System.out.println("ステップ " + i + ": " + Arrays.toString(arr));
}
}
// =======================
// マージソート
// =======================
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);
System.out.println("マージ: " + Arrays.toString(Arrays.copyOfRange(arr, left, right+1)));
}
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);
System.out.println("クイック分割: " + Arrays.toString(arr));
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);
System.out.println("ヒープ化: " + Arrays.toString(arr));
for (int i = n - 1; i >= 0; i--) {
int tmp = arr[0]; arr[0] = arr[i]; arr[i] = tmp;
heapify(arr, i, 0);
System.out.println("ステップ: " + Arrays.toString(arr));
}
}
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;
}
System.out.println("ギャップ " + gap + ": " + Arrays.toString(arr));
}
}
}
💡 ポイント
- 配列のコピー を作って各ソートで独立実行
- 途中経過を出力
- バブル、選択、挿入 → ステップごと
- マージ → マージした範囲ごと
- クイック → 分割ごと
- ヒープ → ヒープ化・スワップごと
- シェル → ギャップごと
- ソートの 動きの違いを視覚的に理解可能