C++递归与迭代两种编程范式的对比与实践应用

#include <iostream>
using namespace std;
// 递归计算阶乘
unsigned long long factorialRecursive(int n) {
    // 基本情况
    if (n == 0) {
        return 1;
    }
    // 递归步骤
    return n * factorialRecursive(n - 1);
}
int main() {
    int num = 10;
    cout << num << "! = " << factorialRecursive(num) << endl;
    return 0;
}

#include <iostream>
using namespace std;
// 迭代计算阶乘
unsigned long long factorialIterative(int n) {
    unsigned long long result = 1;
    // 使用for循环进行迭代
    for (int i = 1; i <= n; ++i) {
        result *= i;
    }
    return result;
}
int main() {
    int num = 10;
    cout << num << "! = " << factorialIterative(num) << endl;
    return 0;
}

// 递归实现斐波那契数列
int fibonacciRecursive(int n) {
    if (n <= 1) {
        return n;
    }
    return fibonacciRecursive(n - 1) + fibonacciRecursive(n - 2);
}

// 迭代实现斐波那契数列
int fibonacciIterative(int n) {
    if (n <= 1) {
        return n;
    }
    int prev_prev = 0; // F(n-2)
    int prev = 1;      // F(n-1)
    int current;       // F(n)
    for (int i = 2; i <= n; ++i) {
        current = prev + prev_prev;
        prev_prev = prev;
        prev = current;
    }
    return current;
}

// 尾递归计算阶乘
unsigned long long factorialTailRecursive(int n, unsigned long long accumulator = 1) {
    if (n == 0) {
        return accumulator;
    }
    // 递归调用是函数的最后一个操作
    return factorialTailRecursive(n - 1, n * accumulator);
}

#include <iostream>
#include <stack>
using namespace std;
// 二叉树节点结构
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
// 递归先序遍历
void preorderRecursive(TreeNode* root) {
    if (root == nullptr) return;
    cout << root->val << " ";       // 访问根节点
    preorderRecursive(root->left);  // 遍历左子树
    preorderRecursive(root->right); // 遍历右子树
}
// 迭代先序遍历
void preorderIterative(TreeNode* root) {
    if (root == nullptr) return;
    stack<TreeNode*> s;
    s.push(root);
    while (!s.empty()) {
        TreeNode* node = s.top();
        s.pop();
        cout << node->val << " ";   // 访问根节点
        // 右子树先入栈，左子树后入栈，保证左子树先访问
        if (node->right != nullptr) {
            s.push(node->right);
        }
        if (node->left != nullptr) {
            s.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);
    cout << "递归先序遍历: ";
    preorderRecursive(root);
    cout << endl;
    cout << "迭代先序遍历: ";
    preorderIterative(root);
    cout << endl;
    // 释放内存（实际应用中应编写完整的销毁函数）
    delete root->left->left;
    delete root->left->right;
    delete root->left;
    delete root->right;
    delete root;
    return 0;
}