C++において、再帰とイテレーションはアルゴリズムを実装する際の基本的な手法です。これらの手法は、特定の問題に対する解決策を提供するために使用され、それぞれが異なる利点と制約を持ちます。本記事では、再帰とイテレーションの基本概念、特性、利点、欠点、および適用シナリオについて詳しく解説します。再帰とイテレーションの使い分けを理解することで、より効率的で最適なコードを書くためのスキルを身につけることができます。
再帰とは何か
再帰（Recursion）とは、関数が自分自身を呼び出す手法です。この手法は、問題を小さなサブプロブレムに分割し、そのサブプロブレムを解決することで元の問題を解決します。再帰的な関数は、基本ケース（ベースケース）と再帰ケースを持つことが特徴です。基本ケースは再帰の終了条件を示し、再帰ケースは関数が自分自身を呼び出す部分です。
再帰の基本構造
再帰関数は以下のように構造化されます：
int factorial(int n) {
if (n <= 1) // 基本ケース
return 1;
else
return n * factorial(n - 1); // 再帰ケース
}この例では、factorial関数が自分自身を呼び出して階乗を計算しています。
再帰の特徴
- シンプルで直感的：自然に問題を分割できるため、コードがわかりやすい。
- メモリ使用量：関数呼び出しごとにスタックフレームが積まれるため、深い再帰はメモリを多く消費する。
- ベースケースの重要性：無限再帰を防ぐために、明確な終了条件（ベースケース）を設定する必要がある。
イテレーションとは何か
イテレーション（Iteration）とは、繰り返し構造を用いて同じ処理を繰り返し実行する手法です。ループ構造（forループ、whileループなど）を用いることで、特定の条件が満たされるまで処理を繰り返します。
イテレーションの基本構造
イテレーションは以下のように構造化されます：
int factorial(int n) {
int result = 1;
for (int i = 1; i <= n; ++i) {
result *= i;
}
return result;
}この例では、factorial関数がforループを使用して階乗を計算しています。
イテレーションの特徴
- 効率性：一般的に、再帰よりもメモリ使用量が少なく、スタックオーバーフローのリスクが低い。
- パフォーマンス：関数呼び出しのオーバーヘッドがないため、再帰よりも高速であることが多い。
- 明示的なループ：ループの範囲や終了条件が明示的に記述されるため、コードが明確。
再帰とイテレーションのいずれを使用するかは、問題の性質や求められるパフォーマンスによります。次のセクションでは、これらの手法の違いとそれぞれの利点・欠点を比較します。
再帰とイテレーションの比較
再帰とイテレーションは、それぞれ異なる利点と欠点を持ちます。以下に、これらの手法の主要な違いと特徴を比較します。
再帰の利点と欠点
利点
- コードのシンプルさ：複雑な問題をシンプルに分割して解決するため、コードが直感的で理解しやすい。
- 自然な問題分割：特に、ツリー構造や分割統治法に適している。
欠点
- メモリ消費：各再帰呼び出しごとにスタックフレームが積まれるため、深い再帰は大量のメモリを消費する可能性がある。
- パフォーマンス：関数呼び出しのオーバーヘッドがあり、特に深い再帰の場合はパフォーマンスが低下する。
イテレーションの利点と欠点
利点
- メモリ効率：スタックフレームを消費しないため、メモリ使用量が少ない。
- パフォーマンス：関数呼び出しのオーバーヘッドがないため、一般的に再帰よりも高速。
欠点
- 複雑なループ：特定の問題では、ループ構造が複雑になり、コードが読みにくくなることがある。
- 自然な問題分割が難しい：ツリー構造や分割統治法など、一部の問題に対しては不自然な実装となることがある。
どちらを選ぶべきか？
選択肢は問題の性質やパフォーマンス要件に依存します。以下の指針を参考にしてください：
- シンプルで直感的な解決策が求められる場合：再帰を選択。
- パフォーマンスやメモリ効率が重要な場合：イテレーションを選択。
次のセクションでは、C++での再帰の具体例とその実装方法を詳しく紹介します。
再帰の具体例
再帰は、特定の問題に対して非常に効果的なアプローチを提供します。ここでは、C++での再帰の具体例として、フィボナッチ数列とハノイの塔の実装を紹介します。
フィボナッチ数列
フィボナッチ数列は、次のように定義される数列です：F(n) = F(n-1) + F(n-2)（ただし、F(0) = 0, F(1) = 1）。再帰を用いると、これを簡単に実装できます。
#include <iostream>
int fibonacci(int n) {
if (n <= 1)
return n;
return fibonacci(n - 1) + fibonacci(n - 2);
}
int main() {
int n = 10; // 例として10番目のフィボナッチ数を計算
std::cout << "Fibonacci(" << n << ") = " << fibonacci(n) << std::endl;
return 0;
}このコードは、再帰を使ってフィボナッチ数列を計算します。
ハノイの塔
ハノイの塔は、複数の円盤を別の棒に移動させる問題で、再帰を用いると非常に効率的に解決できます。
#include <iostream>
void moveDisk(int n, char from, char to, char aux) {
if (n == 1) {
std::cout << "Move disk 1 from " << from << " to " << to << std::endl;
return;
}
moveDisk(n - 1, from, aux, to);
std::cout << "Move disk " << n << " from " << from << " to " << to << std::endl;
moveDisk(n - 1, aux, to, from);
}
int main() {
int n = 3; // 例として3枚の円盤を移動
moveDisk(n, 'A', 'C', 'B');
return 0;
}このコードは、再帰を使用してハノイの塔を解決します。moveDisk関数は、円盤を移動するための再帰的な手法を示しています。
再帰は、特に分割統治法やツリー構造の探索など、自然に問題を分割できる場合に非常に有効です。次のセクションでは、イテレーションの具体例とその実装方法を紹介します。
イテレーションの具体例
イテレーションを用いることで、再帰と同じ問題を効率的に解決することができます。ここでは、C++でのイテレーションの具体例として、フィボナッチ数列と二分探索の実装を紹介します。
フィボナッチ数列
フィボナッチ数列をイテレーションで計算する方法は、再帰よりもメモリ効率が高く、パフォーマンスも向上します。
#include <iostream>
int fibonacci(int n) {
if (n <= 1)
return n;
int a = 0, b = 1, c;
for (int i = 2; i <= n; ++i) {
c = a + b;
a = b;
b = c;
}
return b;
}
int main() {
int n = 10; // 例として10番目のフィボナッチ数を計算
std::cout << "Fibonacci(" << n << ") = " << fibonacci(n) << std::endl;
return 0;
}このコードは、イテレーションを使用してフィボナッチ数列を計算します。ループ構造を用いることで、メモリ消費を抑えながら計算が可能です。
二分探索
二分探索は、ソートされた配列内で特定の値を探す効率的なアルゴリズムです。イテレーションを用いることで、再帰を使用せずに実装できます。
#include <iostream>
#include <vector>
int binarySearch(const std::vector<int>& arr, int target) {
int left = 0, right = arr.size() - 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; // 見つからない場合
}
int main() {
std::vector<int> arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int target = 7; // 例として7を探す
int result = binarySearch(arr, target);
if (result != -1)
std::cout << "Element found at index " << result << std::endl;
else
std::cout << "Element not found" << std::endl;
return 0;
}このコードは、イテレーションを使用して二分探索を実装しています。ループを用いることで、再帰呼び出しのオーバーヘッドを回避し、効率的に検索を行います。
イテレーションは、特にパフォーマンスやメモリ効率が重要な場合に有効です。次のセクションでは、再帰が適している具体的なシナリオや問題例を紹介します。
再帰が適している場合
再帰は、特定の問題やシナリオにおいて非常に効果的です。ここでは、再帰が適している具体的なケースについて説明します。
分割統治法
分割統治法（Divide and Conquer）は、大きな問題を小さなサブプロブレムに分割し、それぞれを解決するアプローチです。再帰は、この手法に自然に適合します。
例：クイックソート
クイックソートは、分割統治法の典型例であり、再帰を使用して効率的にソートを行います。
#include <iostream>
#include <vector>
void quickSort(std::vector<int>& arr, int left, int right) {
int i = left, j = right;
int pivot = arr[(left + right) / 2];
while (i <= j) {
while (arr[i] < pivot)
i++;
while (arr[j] > pivot)
j--;
if (i <= j) {
std::swap(arr[i], arr[j]);
i++;
j--;
}
}
if (left < j)
quickSort(arr, left, j);
if (i < right)
quickSort(arr, i, right);
}
int main() {
std::vector<int> arr = {3, 6, 8, 10, 1, 2, 1};
quickSort(arr, 0, arr.size() - 1);
for (int num : arr)
std::cout << num << " ";
std::cout << std::endl;
return 0;
}この例では、再帰を使用してクイックソートを実装しています。
ツリーやグラフの探索
ツリーやグラフの探索において、再帰は自然なアプローチです。ツリー構造の各ノードを訪問する際に再帰を用いると、コードがシンプルかつ直感的になります。
例：二分探索木のトラバーサル
#include <iostream>
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
void inorderTraversal(TreeNode* root) {
if (root == nullptr)
return;
inorderTraversal(root->left);
std::cout << root->val << " ";
inorderTraversal(root->right);
}
int main() {
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
inorderTraversal(root);
std::cout << std::endl;
return 0;
}この例では、再帰を使用して二分探索木の中序トラバーサルを実装しています。
バックトラッキング
バックトラッキングは、試行錯誤で解を探索するアルゴリズムで、再帰を使うことで非常に効果的に解を見つけることができます。
例：ナップサック問題
#include <iostream>
#include <vector>
int knapsack(int W, const std::vector<int>& weights, const std::vector<int>& values, int n) {
if (n == 0 || W == 0)
return 0;
if (weights[n-1] > W)
return knapsack(W, weights, values, n-1);
else
return std::max(values[n-1] + knapsack(W - weights[n-1], weights, values, n-1),
knapsack(W, weights, values, n-1));
}
int main() {
std::vector<int> weights = {10, 20, 30};
std::vector<int> values = {60, 100, 120};
int W = 50;
int n = weights.size();
std::cout << "Maximum value in Knapsack = " << knapsack(W, weights, values, n) << std::endl;
return 0;
}この例では、再帰を使用してナップサック問題を解決しています。
再帰は、特に問題の分割やツリー構造の探索に非常に有効です。次のセクションでは、イテレーションが適している具体的なシナリオや問題例を紹介します。
イテレーションが適している場合
イテレーションは、特定の問題やシナリオにおいて再帰よりも効果的です。ここでは、イテレーションが適している具体的なケースについて説明します。
シンプルな反復処理
シンプルな反復処理は、イテレーションが非常に適しています。例えば、配列の走査や単純な繰り返し計算などです。
例：配列の最大値を求める
#include <iostream>
#include <vector>
int findMax(const std::vector<int>& arr) {
int maxVal = arr[0];
for (int i = 1; i < arr.size(); ++i) {
if (arr[i] > maxVal) {
maxVal = arr[i];
}
}
return maxVal;
}
int main() {
std::vector<int> arr = {1, 3, 7, 2, 5};
std::cout << "Maximum value in array: " << findMax(arr) << std::endl;
return 0;
}この例では、イテレーションを使用して配列の最大値を求めています。ループを用いることで効率的に最大値を見つけることができます。
状態管理が必要な場合
状態を管理しながら処理を進める場合、イテレーションは有効です。特に、ループの各ステップで状態が変化する場合に適しています。
例：ファイルの行数を数える
#include <iostream>
#include <fstream>
#include <string>
int countLines(const std::string& filename) {
std::ifstream file(filename);
std::string line;
int count = 0;
while (std::getline(file, line)) {
++count;
}
return count;
}
int main() {
std::string filename = "example.txt";
std::cout << "Number of lines in " << filename << ": " << countLines(filename) << std::endl;
return 0;
}この例では、イテレーションを使用してファイルの行数を数えています。各行を読み込むたびにカウントを増やすため、ループが適しています。
パフォーマンスが重要な場合
再帰よりもイテレーションの方がパフォーマンスが良い場合があります。特に、再帰呼び出しのオーバーヘッドが問題となる場合に有効です。
例：数列の合計を計算
#include <iostream>
#include <vector>
int sumArray(const std::vector<int>& arr) {
int sum = 0;
for (int i = 0; i < arr.size(); ++i) {
sum += arr[i];
}
return sum;
}
int main() {
std::vector<int> arr = {1, 2, 3, 4, 5};
std::cout << "Sum of array: " << sumArray(arr) << std::endl;
return 0;
}この例では、イテレーションを使用して数列の合計を計算しています。ループを用いることで、高速に処理を行うことができます。
動的計画法
動的計画法（Dynamic Programming）は、イテレーションを使用して部分問題を解決し、結果を蓄積していく手法です。これにより、重複計算を避けて効率的に問題を解決します。
例：フィボナッチ数列（動的計画法）
#include <iostream>
#include <vector>
int fibonacci(int n) {
if (n <= 1)
return n;
std::vector<int> fib(n+1);
fib[0] = 0;
fib[1] = 1;
for (int i = 2; i <= n; ++i) {
fib[i] = fib[i-1] + fib[i-2];
}
return fib[n];
}
int main() {
int n = 10;
std::cout << "Fibonacci(" << n << ") = " << fibonacci(n) << std::endl;
return 0;
}この例では、動的計画法を用いてフィボナッチ数列を計算しています。イテレーションを使用することで、重複計算を避けつつ効率的に計算を行います。
イテレーションは、シンプルな反復処理や状態管理が必要な場合、またパフォーマンスが重要な場合に非常に有効です。次のセクションでは、パフォーマンスの観点から再帰とイテレーションの選択について解説します。
パフォーマンスの観点からの選択
再帰とイテレーションのどちらを選択するかは、パフォーマンスの観点から重要な決定となります。それぞれの手法が持つパフォーマンス上の特性を理解し、適切に選択することが求められます。
再帰のパフォーマンス
再帰は、特定の問題に対して自然で直感的な解決策を提供しますが、パフォーマンスにはいくつかの制約があります。
スタックオーバーフローのリスク
再帰関数は、関数呼び出しごとにスタックフレームを積むため、再帰の深さが深くなるとスタックオーバーフローが発生するリスクがあります。
int factorial(int n) {
if (n <= 1)
return 1;
return n * factorial(n - 1);
}この例では、factorial関数が再帰的に呼び出されますが、nが非常に大きくなるとスタックオーバーフローのリスクがあります。
関数呼び出しのオーバーヘッド
再帰関数の呼び出しにはオーバーヘッドが伴います。これにより、イテレーションに比べてパフォーマンスが低下する場合があります。
イテレーションのパフォーマンス
イテレーションは、一般的に再帰に比べてパフォーマンスが高く、メモリ効率が良いです。
低いオーバーヘッド
ループを使用する場合、関数呼び出しのオーバーヘッドがないため、処理が高速です。
int factorial(int n) {
int result = 1;
for (int i = 1; i <= n; ++i) {
result *= i;
}
return result;
}この例では、ループを使用して階乗を計算しています。再帰と比べてオーバーヘッドが少なく、効率的です。
メモリ効率
イテレーションは、スタックフレームを消費しないため、再帰に比べてメモリ効率が良いです。これにより、大規模なデータセットや深い再帰が必要な問題に対しても有効です。
再帰の最適化技術
再帰のパフォーマンスを改善するための技術も存在します。
尾再帰最適化
尾再帰最適化（Tail Recursion Optimization）は、再帰呼び出しが関数の最後に行われる場合に、スタックフレームを再利用してオーバーヘッドを減少させる技術です。
int factorialHelper(int n, int accumulator) {
if (n <= 1)
return accumulator;
return factorialHelper(n - 1, n * accumulator);
}
int factorial(int n) {
return factorialHelper(n, 1);
}この例では、factorialHelper関数が尾再帰最適化を利用しています。
選択の指針
- 問題の複雑さ：自然な問題分割が必要な場合は再帰を選択。単純な反復処理や状態管理が必要な場合はイテレーションを選択。
- パフォーマンス：再帰のオーバーヘッドが問題になる場合はイテレーションを選択。
- メモリ効率：大規模データや深い再帰が必要な場合はイテレーションを選択。
次のセクションでは、ツリー構造の探索における再帰とイテレーションの使い方を具体例を交えて解説します。
応用例：ツリー構造の探索
ツリー構造の探索は、再帰とイテレーションの両方を用いることができる典型的な問題です。ここでは、二分探索木（Binary Search Tree, BST）の深さ優先探索（DFS）と幅優先探索（BFS）について、再帰とイテレーションの両方の実装方法を紹介します。
深さ優先探索（DFS）
深さ優先探索は、再帰を用いることで自然に実装できます。以下に、再帰とイテレーションの両方の方法を示します。
再帰を用いたDFS
#include <iostream>
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
void dfs(TreeNode* root) {
if (root == nullptr)
return;
std::cout << root->val << " "; // ノードの処理
dfs(root->left); // 左部分木の探索
dfs(root->right); // 右部分木の探索
}
int main() {
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
dfs(root);
std::cout << std::endl;
return 0;
}この例では、再帰を用いて二分探索木のDFSを実装しています。シンプルで直感的なコードです。
イテレーションを用いたDFS
#include <iostream>
#include <stack>
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
void dfs(TreeNode* root) {
if (root == nullptr)
return;
std::stack<TreeNode*> stack;
stack.push(root);
while (!stack.empty()) {
TreeNode* node = stack.top();
stack.pop();
std::cout << node->val << " "; // ノードの処理
if (node->right)
stack.push(node->right);
if (node->left)
stack.push(node->left);
}
}
int main() {
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
dfs(root);
std::cout << std::endl;
return 0;
}この例では、スタックを用いて二分探索木のDFSをイテレーションで実装しています。
幅優先探索（BFS）
幅優先探索は、通常キューを使用してイテレーションで実装します。以下にBFSの実装方法を示します。
イテレーションを用いたBFS
#include <iostream>
#include <queue>
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
void bfs(TreeNode* root) {
if (root == nullptr)
return;
std::queue<TreeNode*> queue;
queue.push(root);
while (!queue.empty()) {
TreeNode* node = queue.front();
queue.pop();
std::cout << node->val << " "; // ノードの処理
if (node->left)
queue.push(node->left);
if (node->right)
queue.push(node->right);
}
}
int main() {
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
bfs(root);
std::cout << std::endl;
return 0;
}この例では、キューを用いて二分探索木のBFSをイテレーションで実装しています。
ツリー探索の選択
- 再帰：シンプルで直感的なコードが求められる場合に有効。ただし、スタックオーバーフローのリスクがある。
- イテレーション：パフォーマンスやメモリ効率が重要な場合に有効。スタックオーバーフローのリスクがない。
次のセクションでは、再帰とイテレーションを組み合わせた実装方法について紹介します。
再帰とイテレーションの混在
再帰とイテレーションを組み合わせることで、特定の問題に対してより柔軟で効率的な解決策を提供できます。ここでは、再帰とイテレーションを組み合わせた実装方法について、いくつかの例を示します。
例：ツリーの高さを求める
ツリーの高さを求める問題では、再帰を用いて部分木の高さを計算し、イテレーションを用いて全体の高さを求めることができます。
再帰を用いた部分木の高さ計算
#include <iostream>
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
int height(TreeNode* node) {
if (node == nullptr)
return 0;
int leftHeight = height(node->left);
int rightHeight = height(node->right);
return std::max(leftHeight, rightHeight) + 1;
}
int main() {
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
std::cout << "Height of tree: " << height(root) << std::endl;
return 0;
}この例では、再帰を使用して各部分木の高さを計算し、それらを比較してツリー全体の高さを求めています。
例：再帰とイテレーションを組み合わせたパス探索
再帰とイテレーションを組み合わせることで、パス探索のパフォーマンスを向上させることができます。以下に、迷路のパス探索を再帰とイテレーションで実装する例を示します。
再帰とイテレーションを組み合わせた迷路のパス探索
#include <iostream>
#include <vector>
#include <stack>
const int ROWS = 5;
const int COLS = 5;
bool isSafe(int x, int y, const std::vector<std::vector<int>>& maze, std::vector<std::vector<bool>>& visited) {
return (x >= 0 && x < ROWS && y >= 0 && y < COLS && maze[x][y] == 1 && !visited[x][y]);
}
bool solveMazeUtil(int x, int y, std::vector<std::vector<int>>& maze, std::vector<std::vector<bool>>& visited) {
if (x == ROWS - 1 && y == COLS - 1) {
visited[x][y] = true;
return true;
}
if (isSafe(x, y, maze, visited)) {
visited[x][y] = true;
// 下方向へ移動
if (solveMazeUtil(x + 1, y, maze, visited))
return true;
// 右方向へ移動
if (solveMazeUtil(x, y + 1, maze, visited))
return true;
// 移動が無理な場合はバックトラック
visited[x][y] = false;
}
return false;
}
void solveMaze(std::vector<std::vector<int>>& maze) {
std::vector<std::vector<bool>> visited(ROWS, std::vector<bool>(COLS, false));
if (solveMazeUtil(0, 0, maze, visited)) {
for (int i = 0; i < ROWS; ++i) {
for (int j = 0; j < COLS; ++j) {
std::cout << (visited[i][j] ? "1 " : "0 ");
}
std::cout << std::endl;
}
} else {
std::cout << "No solution found." << std::endl;
}
}
int main() {
std::vector<std::vector<int>> maze = {
{1, 0, 0, 0, 0},
{1, 1, 0, 1, 0},
{0, 1, 1, 1, 0},
{0, 0, 0, 1, 0},
{1, 1, 1, 1, 1}
};
solveMaze(maze);
return 0;
}この例では、再帰を用いて迷路のパスを探索し、イテレーションを用いて結果を表示しています。再帰を利用することで、パスの探索が直感的かつシンプルになり、イテレーションを用いることで結果の処理が効率的に行えます。
再帰とイテレーションのハイブリッドアプローチ
再帰とイテレーションを組み合わせることで、複雑な問題に対して柔軟で効率的な解決策を提供できます。例えば、再帰的なアプローチを用いて部分問題を解決し、その結果をイテレーションで処理することで、全体のパフォーマンスを向上させることができます。
次のセクションでは、再帰とイテレーションの使い分けのポイントと本記事の総括を行います。
まとめ
C++における再帰とイテレーションは、それぞれ異なる特性と利点を持つ重要な手法です。本記事では、再帰とイテレーションの基本概念、特徴、具体例、適用シナリオ、パフォーマンスの観点、ツリー構造の探索方法、そして両者を組み合わせたアプローチについて詳しく解説しました。
再帰は、分割統治法やツリー構造の探索において自然な解決策を提供し、コードをシンプルで直感的に保つことができます。一方、イテレーションは、パフォーマンスとメモリ効率の面で優れており、単純な反復処理や状態管理が必要な場合に特に有効です。
再帰とイテレーションの使い分けを理解し、適切に選択することで、より効率的で最適なプログラムを構築することができます。特定の問題やシナリオに応じて、再帰とイテレーションの利点を最大限に活用し、柔軟で効果的なコードを書いてください。
以上で、C++の再帰とイテレーションの使い分けに関する解説を終了します。これを機に、皆さんが自身のプログラムにおいて再帰とイテレーションを上手に使い分け、より高度なプログラミングスキルを身につけられることを願っています。
コメント