xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-11-04 04:02:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

Retranslate the complete Japanese online edition from Chinese (#2008)

Browse Source 
* Retranslate the complete Japanese online edition from Chinese

* Fit Japanese homepage labels and localize heading permalinks

* Point Japanese contribution instructions to the Japanese preview

* Replace locale conditionals with multilingual UI tables
This commit is contained in:
Yudong Jin
2026-10-30 02:12:26 +08:00
committed by GitHub
parent 455e8c1281
commit 7257641e0e
1987 changed files with 23531 additions and 23261 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ja/codes/cpp/chapter_sorting/bubble_sort.cpp
+8 -8
View File
@@ -10,37 +10,37 @@
void bubbleSort(vector<int> &nums) {
// 外側のループ：未ソート区間は [0, i]
for (int i = nums.size() - 1; i > 0; i--) {
// 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
// 内側のループ：未ソート区間 [0, i] の最大要素を区間の右端に移す
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// nums[j] と nums[j + 1] を交換する
// ここでは std::swap() 関数を使用する
// ここでは std::swap() 関数を使う
swap(nums[j], nums[j + 1]);
}
}
}
}
/* バブルソート（フラグ最適化） */
/* バブルソート（フラグによる最適化）*/
void bubbleSortWithFlag(vector<int> &nums) {
// 外側のループ：未ソート区間は [0, i]
for (int i = nums.size() - 1; i > 0; i--) {
bool flag = false; // フラグを初期化する
// 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
// 内側のループ：未ソート区間 [0, i] の最大要素を区間の右端に移す
for (int j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// nums[j] と nums[j + 1] を交換する
// ここでは std::swap() 関数を使用する
// ここでは std::swap() 関数を使う
swap(nums[j], nums[j + 1]);
flag = true; // 交換する要素を記録
flag = true; // 要素を交換したことを記録する
}
}
if (!flag)
break; // このバブル処理で要素交換が一度もなければそのまま終了
break; // 今回の「バブル」で要素を一度も交換しなかった場合、直ちに終了する
}
}
/* Driver Code */
/* 実行用コード */
int main() {
vector<int> nums = {4, 1, 3, 1, 5, 2};
bubbleSort(nums);
ja/codes/cpp/chapter_sorting/bucket_sort.cpp
+7 -7
View File
@@ -8,14 +8,14 @@
/* バケットソート */
void bucketSort(vector<float> &nums) {
// k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする
// k = n/2 個のバケットを初期化し、各バケットに平均 2 個の要素を割り当てることを想定する
int k = nums.size() / 2;
vector<vector<float>> buckets(k);
// 1. 配列要素を各バケットに振り分ける
// 1. 配列の要素を各バケットに振り分ける
for (float num : nums) {
// 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する
// 入力データの範囲は [0, 1) なので、num * k によりインデックス範囲 [0, k-1] に対応付ける
int i = num * k;
// num をバケット bucket_idx に追加
// num をバケット bucket_idx に追加する
buckets[i].push_back(num);
}
// 2. 各バケットをソートする
@@ -23,7 +23,7 @@ void bucketSort(vector<float> &nums) {
// 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい
sort(bucket.begin(), bucket.end());
}
// 3. バケットを走査して結果を結合
// 3. バケットを走査して結果を結合する
int i = 0;
for (vector<float> &bucket : buckets) {
for (float num : bucket) {
@@ -32,9 +32,9 @@ void bucketSort(vector<float> &nums) {
}
}
/* Driver Code */
/* 実行用コード */
int main() {
// 入力データは範囲 [0, 1) の浮動小数点数とする
// 入力データは [0, 1) の範囲の浮動小数点数とする
vector<float> nums = {0.49f, 0.96f, 0.82f, 0.09f, 0.57f, 0.43f, 0.91f, 0.75f, 0.15f, 0.37f};
bucketSort(nums);
cout << "バケットソート完了後 nums = ";
ja/codes/cpp/chapter_sorting/counting_sort.cpp
+13 -13
View File
@@ -6,8 +6,8 @@
#include "../utils/common.hpp"
/* 計数ソート */
// 簡易実装のため、オブジェクトのソートには使えない
/* カウントソート */
// 簡易実装。オブジェクトのソートには使えない
void countingSortNaive(vector<int> &nums) {
// 1. 配列の最大要素 m を求める
int m = 0;
@@ -20,7 +20,7 @@ void countingSortNaive(vector<int> &nums) {
for (int num : nums) {
counter[num]++;
}
// 3. counter を走査し、各要素を元の配列 nums に書き戻す
// 3. counter を走査し、各要素を元の配列 nums に入れる
int i = 0;
for (int num = 0; num < m + 1; num++) {
for (int j = 0; j < counter[num]; j++, i++) {
@@ -29,8 +29,8 @@ void countingSortNaive(vector<int> &nums) {
}
}
/* 計数ソート */
// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである
/* カウントソート */
// 完全な実装。オブジェクトをソートでき、安定ソートである
void countingSort(vector<int> &nums) {
// 1. 配列の最大要素 m を求める
int m = 0;
@@ -43,29 +43,29 @@ void countingSort(vector<int> &nums) {
for (int num : nums) {
counter[num]++;
}
// 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する
// つまり counter[num]-1 は、num が res に最後に現れるインデックス
// 3. counter の累積和を求め、「出現回数」を「末尾のインデックス」に変換する
// つまり、counter[num]-1 は res 内で num が最後に現れるインデックスである
for (int i = 0; i < m; i++) {
counter[i + 1] += counter[i];
}
// 4. nums を逆順に走査し、各要素を結果配列 res に格納する
// 結果を記録するための配列 res を初期化
// 4. nums を逆順に走査し、各要素を結果配列 res に入れる
// 結果を記録する配列 res を初期化する
int n = nums.size();
vector<int> res(n);
for (int i = n - 1; i >= 0; i--) {
int num = nums[i];
res[counter[num] - 1] = num; // num を対応するインデックスに配置
counter[num]--; // 累積和を 1 減らして、次に num を配置するインデックスを得る
res[counter[num] - 1] = num; // 対応するインデックスに num を配置する
counter[num]--; // 累積和を 1 減らし、次に num を配置するインデックスを求める
}
// 結果配列 res で元の配列 nums を上書きする
nums = res;
}
/* Driver Code */
/* 実行用コード */
int main() {
vector<int> nums = {1, 0, 1, 2, 0, 4, 0, 2, 2, 4};
countingSortNaive(nums);
cout << "カウントソート（オブジェクトはソートできない）完了後 nums = ";
cout << "カウントソート（オブジェクトはソート不可）の完了後 nums = ";
printVector(nums);
vector<int> nums1 = {1, 0, 1, 2, 0, 4, 0, 2, 2, 4};
ja/codes/cpp/chapter_sorting/heap_sort.cpp
+10 -10
View File
@@ -6,10 +6,10 @@
#include "../utils/common.hpp"
/* ヒープの長さは n。ノード i から下方向にヒープ化 */
/* 長さ n のヒープを、ノード i から下向きにヒープ化する */
void siftDown(vector<int> &nums, int n, int i) {
while (true) {
// ノード i, l, r のうち値が最大のノードを ma とする
// ノード i, l, r のうち値が最大のノードを求め、ma とする
int l = 2 * i + 1;
int r = 2 * i + 2;
int ma = i;
@@ -17,33 +17,33 @@ void siftDown(vector<int> &nums, int n, int i) {
ma = l;
if (r < n && nums[r] > nums[ma])
ma = r;
// ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
// ノード i が最大か添字 l, r が範囲外なら、ヒープ化は不要なので終了
if (ma == i) {
break;
}
// 2 つのノードを交換
// 2 つのノードを交換する
swap(nums[i], nums[ma]);
// ループで上から下へヒープ化
// 下向きのヒープ化を繰り返す
i = ma;
}
}
/* ヒープソート */
void heapSort(vector<int> &nums) {
// ヒープ構築：葉ノード以外のすべてのノードをヒープ化する
// ヒープの構築：葉ノード以外の全ノードをヒープ化する
for (int i = nums.size() / 2 - 1; i >= 0; --i) {
siftDown(nums, nums.size(), i);
}
// ヒープから最大要素を取り出し、n-1 回繰り返す
// ヒープから最大要素を取り出す処理を n-1 回繰り返す
for (int i = nums.size() - 1; i > 0; --i) {
// 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
// 根と最右の葉を交換（先頭要素と末尾要素を交換）
swap(nums[0], nums[i]);
// 根ノードを起点に、上から下へヒープ化
// 根ノードから下向きにヒープ化する
siftDown(nums, i, 0);
}
}
/* Driver Code */
/* 実行用コード */
int main() {
vector<int> nums = {4, 1, 3, 1, 5, 2};
heapSort(nums);
ja/codes/cpp/chapter_sorting/insertion_sort.cpp
+5 -5
View File
@@ -8,19 +8,19 @@
/* 挿入ソート */
void insertionSort(vector<int> &nums) {
// 外側ループ：整列済み区間は [0, i-1]
// 外側のループ：ソート済み区間は [0, i-1]
for (int i = 1; i < nums.size(); i++) {
int base = nums[i], j = i - 1;
// 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する
// 内側のループ：ソート済み区間 [0, i-1] の正しい位置に base を挿入する
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する
nums[j + 1] = nums[j]; // nums[j] を右に 1 つずらす
j--;
}
nums[j + 1] = base; // base を正しい位置に配置する
nums[j + 1] = base; // 正しい位置に base を代入する
}
}
/* Driver Code */
/* 実行用コード */
int main() {
vector<int> nums = {4, 1, 3, 1, 5, 2};
insertionSort(nums);
ja/codes/cpp/chapter_sorting/merge_sort.cpp
+13 -13
View File
@@ -6,28 +6,28 @@
#include "../utils/common.hpp"
/* 左部分配列と右部分配列をマージ */
/* 左部分配列と右部分配列をマージする */
void merge(vector<int> &nums, int left, int mid, int right) {
// 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]
// マージ結果を格納する一時配列 tmp を作成
// マージ後の結果を格納する一時配列 tmp を作成する
vector<int> tmp(right - left + 1);
// 左右の部分配列の開始インデックスを初期化する
// 左部分配列と右部分配列の開始インデックスを初期化する
int i = left, j = mid + 1, k = 0;
// 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする
// 左右両方の部分配列に要素が残っている間、比較して小さいほうの要素を一時配列にコピーする
while (i <= mid && j <= right) {
if (nums[i] <= nums[j])
tmp[k++] = nums[i++];
else
tmp[k++] = nums[j++];
}
// 左右の部分配列の残り要素を一時配列にコピーする
// 左部分配列と右部分配列の残りの要素を一時配列にコピーする
while (i <= mid) {
tmp[k++] = nums[i++];
}
while (j <= right) {
tmp[k++] = nums[j++];
}
// 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする
// 一時配列 tmp の要素を元の配列 nums の対応する区間にコピーし戻す
for (k = 0; k < tmp.size(); k++) {
nums[left + k] = tmp[k];
}
@@ -37,16 +37,16 @@ void merge(vector<int> &nums, int left, int mid, int right) {
void mergeSort(vector<int> &nums, int left, int right) {
// 終了条件
if (left >= right)
return; // 部分配列の長さが 1 になったら再帰を終了
// 分割フェーズ
int mid = left + (right - left) / 2; // 中点を計算
mergeSort(nums, left, mid); // 左部分配列を再帰処理
mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理
// マージフェーズ
return; // 部分配列の長さが 1 になったら再帰を終了する
// 分割段階
int mid = left + (right - left) / 2; // 中央を計算する
mergeSort(nums, left, mid); // 左部分配列を再帰的に処理する
mergeSort(nums, mid + 1, right); // 右部分配列を再帰的に処理する
// マージ段階
merge(nums, left, mid, right);
}
/* Driver Code */
/* 実行用コード */
int main() {
/* マージソート */
vector<int> nums = {7, 3, 2, 6, 0, 1, 5, 4};
ja/codes/cpp/chapter_sorting/quick_sort.cpp
+46 -46
View File
@@ -9,119 +9,119 @@
/* クイックソートクラス */
class QuickSort {
private:
/* 番兵分割 */
/* 番兵を用いた分割 */
static int partition(vector<int> &nums, int left, int right) {
// nums[left] を基準値とする
// nums[left] をピボットとする
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left])
j--; // 右から左へ基準値未満の最初の要素を探す
j--; // 右から左へ、ピボットより小さい最初の要素を探す
while (i < j && nums[i] <= nums[left])
i++; // 左から右へ基準値より大きい最初の要素を探す
swap(nums[i], nums[j]); // この 2 つの要素を交換
i++; // 左から右へ、ピボットより大きい最初の要素を探す
swap(nums[i], nums[j]); // この 2 つの要素を交換する
}
swap(nums[i], nums[left]); // 基準値を 2 つの部分配列の境界へ交換する
return i; // 基準値のインデックスを返す
swap(nums[i], nums[left]); // ピボットを 2 つの部分配列の境界に移す
return i; // ピボットのインデックスを返す
}
public:
/* クイックソート */
static void quickSort(vector<int> &nums, int left, int right) {
// 部分配列の長さが 1 なら再帰を終了する
// 部分配列の長さが 1 になったら再帰を終了する
if (left >= right)
return;
// 番兵分割
// 番兵を用いた分割
int pivot = partition(nums, left, right);
// 左右の部分配列を再帰処理
// 左部分配列と右部分配列を再帰的に処理する
quickSort(nums, left, pivot - 1);
quickSort(nums, pivot + 1, right);
}
};
/* クイックソートクラス（中央値ピボット最適化） */
/* クイックソートクラス（中央値ピボットによる最適化） */
class QuickSortMedian {
private:
/* 3つの候補要素の中央値を選ぶ */
/* 候補となる 3 要素の中央値を選ぶ */
static int medianThree(vector<int> &nums, int left, int mid, int right) {
int l = nums[left], m = nums[mid], r = nums[right];
if ((l <= m && m <= r) || (r <= m && m <= l))
return mid; // m は l と r の間
return mid; // m が l と r の間にある
if ((m <= l && l <= r) || (r <= l && l <= m))
return left; // l は m と r の間
return left; // l が m と r の間にある
return right;
}
/* 番兵による分割処理（3 点中央値） */
/* 番兵を用いた分割（3 値の中央値を選択） */
static int partition(vector<int> &nums, int left, int right) {
// 3つの候補要素の中央値を選ぶ
// 候補となる 3 要素の中央値を選ぶ
int med = medianThree(nums, left, (left + right) / 2, right);
// 中央値を配列の最左端に交換する
// 中央値を配列の左端に移す
swap(nums[left], nums[med]);
// nums[left] を基準値とする
// nums[left] をピボットとする
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left])
j--; // 右から左へ基準値未満の最初の要素を探す
j--; // 右から左へ、ピボットより小さい最初の要素を探す
while (i < j && nums[i] <= nums[left])
i++; // 左から右へ基準値より大きい最初の要素を探す
swap(nums[i], nums[j]); // この 2 つの要素を交換
i++; // 左から右へ、ピボットより大きい最初の要素を探す
swap(nums[i], nums[j]); // この 2 つの要素を交換する
}
swap(nums[i], nums[left]); // 基準値を 2 つの部分配列の境界へ交換する
return i; // 基準値のインデックスを返す
swap(nums[i], nums[left]); // ピボットを 2 つの部分配列の境界に移す
return i; // ピボットのインデックスを返す
}
public:
/* クイックソート */
static void quickSort(vector<int> &nums, int left, int right) {
// 部分配列の長さが 1 なら再帰を終了する
// 部分配列の長さが 1 になったら再帰を終了する
if (left >= right)
return;
// 番兵分割
// 番兵を用いた分割
int pivot = partition(nums, left, right);
// 左右の部分配列を再帰処理
// 左部分配列と右部分配列を再帰的に処理する
quickSort(nums, left, pivot - 1);
quickSort(nums, pivot + 1, right);
}
};
/* クイックソートクラス（再帰深度最適化） */
/* クイックソートクラス（再帰の深さの最適化） */
class QuickSortTailCall {
private:
/* 番兵分割 */
/* 番兵を用いた分割 */
static int partition(vector<int> &nums, int left, int right) {
// nums[left] を基準値とする
// nums[left] をピボットとする
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left])
j--; // 右から左へ基準値未満の最初の要素を探す
j--; // 右から左へ、ピボットより小さい最初の要素を探す
while (i < j && nums[i] <= nums[left])
i++; // 左から右へ基準値より大きい最初の要素を探す
swap(nums[i], nums[j]); // この 2 つの要素を交換
i++; // 左から右へ、ピボットより大きい最初の要素を探す
swap(nums[i], nums[j]); // この 2 つの要素を交換する
}
swap(nums[i], nums[left]); // 基準値を 2 つの部分配列の境界へ交換する
return i; // 基準値のインデックスを返す
swap(nums[i], nums[left]); // ピボットを 2 つの部分配列の境界に移す
return i; // ピボットのインデックスを返す
}
public:
/* クイックソート（再帰深度最適化） */
/* クイックソート（再帰の深さの最適化） */
static void quickSort(vector<int> &nums, int left, int right) {
// 部分配列の長さが 1 なら終了
// 部分配列の長さが 1 になったら終了する
while (left < right) {
// 番兵による分割処理
// 番兵を用いた分割操作
int pivot = partition(nums, left, right);
// 2 つの部分配列のうち短いほうにクイックソートを適用する
if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート
left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]
quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソートする
left = pivot + 1; // 残りの未ソート区間は [pivot + 1, right]
} else {
quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート
right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]
quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソートする
right = pivot - 1; // 残りの未ソート区間は [left, pivot - 1]
}
}
}
};
/* Driver Code */
/* 実行用コード */
int main() {
/* クイックソート */
vector<int> nums{2, 4, 1, 0, 3, 5};
@@ -129,16 +129,16 @@ int main() {
cout << "クイックソート完了後 nums = ";
printVector(nums);
/* クイックソート（中央値の基準値で最適化） */
/* クイックソート（中央値ピボットによる最適化） */
vector<int> nums1 = {2, 4, 1, 0, 3, 5};
QuickSortMedian::quickSort(nums1, 0, nums1.size() - 1);
cout << "クイックソート（中央値ピボット最適化）完了後 nums = ";
cout << "クイックソート（中央値ピボットによる最適化）の完了後 nums = ";
printVector(nums1);
/* クイックソート（再帰深度最適化） */
/* クイックソート（再帰の深さの最適化） */
vector<int> nums2 = {2, 4, 1, 0, 3, 5};
QuickSortTailCall::quickSort(nums2, 0, nums2.size() - 1);
cout << "クイックソート（再帰深度最適化）完了後 nums = ";
cout << "クイックソート（再帰の深さの最適化）の完了後 nums = ";
printVector(nums2);
return 0;
ja/codes/cpp/chapter_sorting/radix_sort.cpp
+14 -14
View File
@@ -6,32 +6,32 @@
#include "../utils/common.hpp"
/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */
/* 要素 num の第 k 桁を取得する。exp = 10^(k-1) とする */
int digit(int num, int exp) {
// ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す
// k ではなく exp を渡すことで、ここで高コストのべき乗計算を繰り返すのを避ける
return (num / exp) % 10;
}
/* 計数ソート（nums の k 桁目でソート） */
/* カウントソート（nums の第 k 桁に基づくソート） */
void countingSortDigit(vector<int> &nums, int exp) {
// 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要
// 十進数の各桁の範囲は 0~9 なので、長さ 10 のバケット配列が必要
vector<int> counter(10, 0);
int n = nums.size();
// 0~9 の各数字の出現回数を集計する
// 0~9 の各数字の出現回数を数える
for (int i = 0; i < n; i++) {
int d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする
int d = digit(nums[i], exp); // nums[i] の第 k 桁を取得し、d とする
counter[d]++; // 数字 d の出現回数を数える
}
// 累積和を求め、「出現回数」を「配列インデックス」に変換する
// 累積和を求め、「出現回数」を「配列のインデックス」に変換する
for (int i = 1; i < 10; i++) {
counter[i] += counter[i - 1];
}
// 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する
// 逆順に走査し、バケット内の集計結果に基づいて各要素を res に入れる
vector<int> res(n, 0);
for (int i = n - 1; i >= 0; i--) {
int d = digit(nums[i], exp);
int j = counter[d] - 1; // d の配列内インデックス j を取得する
res[j] = nums[i]; // 現在の要素をインデックス j に格納する
int j = counter[d] - 1; // 配列内での d のインデックス j を取得する
res[j] = nums[i]; // 現在の要素をインデックス j に入れる
counter[d]--; // d の個数を 1 減らす
}
// 結果で元の配列 nums を上書きする
@@ -41,18 +41,18 @@ void countingSortDigit(vector<int> &nums, int exp) {
/* 基数ソート */
void radixSort(vector<int> &nums) {
// 最大桁数の判定用に配列の最大要素を取得
// 最大桁数を判定するため、配列の最大要素を取得する
int m = *max_element(nums.begin(), nums.end());
// 下位桁から上位桁の順に走査する
// 下位の桁から上位の桁へ順に走査する
for (int exp = 1; exp <= m; exp *= 10)
// 配列要素の k 桁目に対して計数ソートを行う
// 配列の要素の第 k 桁に対してカウントソートを行う
// k = 1 -> exp = 1
// k = 2 -> exp = 10
// つまり exp = 10^(k-1)
countingSortDigit(nums, exp);
}
/* Driver Code */
/* 実行用コード */
int main() {
// 基数ソート
vector<int> nums = {10546151, 35663510, 42865989, 34862445, 81883077,
ja/codes/cpp/chapter_sorting/selection_sort.cpp
+5 -5
View File
@@ -9,20 +9,20 @@
/* 選択ソート */
void selectionSort(vector<int> &nums) {
int n = nums.size();
// 外側ループ：未整列区間は [i, n-1]
// 外側のループ：未ソート区間は [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; // 最小要素のインデックスを記録
k = j; // 最小要素のインデックスを記録する
}
// その最小要素を未整列区間の先頭要素と交換する
// この最小要素を未ソート区間の先頭要素と交換する
swap(nums[i], nums[k]);
}
}
/* Driver Code */
/* 実行用コード */
int main() {
vector<int> nums = {4, 1, 3, 1, 5, 2};
selectionSort(nums);