迭代与递归-CSDN博客

本文链接：https://blog.csdn.net/m0_67996574/article/details/140237635

迭代和递归是两种常见的编程技术，用于解决需要重复执行相同或相似任务的问题。它们在算法设计和程序实现中都扮演着重要角色，但各自有独特的特性和适用场景。

迭代

迭代是一种通过循环结构来重复执行一段代码的编程方法。在迭代中，程序使用循环（如for、while循环）重复执行相同的代码块直到满足特定条件为止。迭代通常用于处理已知边界条件的问题，比如遍历数组、执行固定次数的计算等。

特点：

控制流清晰：迭代通常有明确的开始和结束条件，易于理解和调试。
内存效率高：迭代通常不需要额外的栈空间，因此内存消耗相对较低。
性能优势：在处理大规模数据集时，迭代可能比递归更高效，因为它避免了函数调用的开销。

递归

递归是一种函数调用自身的编程技术。递归解决方案通常依赖于将问题分解成更小的子问题，直到达到基本情况（base case），然后逐步构建解决方案。递归在处理树状结构、深度优先搜索、数学问题（如阶乘、斐波那契数列）等方面特别有用。

特点：

代码简洁：递归代码往往更短，更直观，特别是当问题可以自然地分解为相似的子问题时。
抽象能力强：递归能够自然地表达复杂问题的抽象结构，简化问题的描述。
潜在风险：递归可能导致栈溢出错误，特别是在深度很大的递归调用链中。递归调用的开销也可能影响性能。

经典案例
数组元素求和：通过迭代计算数组中所有元素的总和。

public static int SumArray(int[] arr)
{
    int sum = 0;
    foreach (int num in arr)
    {
        sum += num;
    }
    return sum;
}

数组元素乘积：通过迭代计算数组中所有元素的乘积。

public static long ProductArray(int[] arr)
{
    long product = 1;
    foreach (int num in arr)
    {
        product *= num;
    }
    return product;
}

数组元素平均值：通过迭代计算数组中所有元素的平均值。

public static double AverageArray(int[] arr)
{
    int sum = 0;
    foreach (int num in arr)
    {
        sum += num;
    }
    return (double)sum / arr.Length;
}

查找数组中的最大值：通过迭代找到数组中的最大值。

public static int MaxValue(int[] arr)
{
    int max = arr[0];
    for (int i = 1; i < arr.Length; i++)
    {
        if (arr[i] > max)
        {
            max = arr[i];
        }
    }
    return max;
}

查找数组中的偶数：通过迭代筛选出数组中的所有偶数。

public static List<int> GetEvens(int[] arr)
{
    List<int> evens = new List<int>();
    foreach (int num in arr)
    {
        if (num % 2 == 0)
        {
            evens.Add(num);
        }
    }
    return evens;
}

计算阶乘：使用递归来计算给定非负整数的阶乘。

public static long CalculateFactorial(int number)
{
    if (number <= 1)
    {
        return 1;
    }
    return number * CalculateFactorial(number - 1);
}

数组翻转：使用迭代来翻转一个整数数组。

public static void ReverseArray(int[] arr)
{
    Array.Reverse(arr);
}

字符串反转：通过迭代反转一个字符串。

public static string ReverseString(string str)
{
    char[] charArray = str.ToCharArray();
    Array.Reverse(charArray);
    return new string(charArray);
}

检查回文：使用迭代检查一个字符串是否是回文。

public static bool IsPalindrome(string str)
{
    int left = 0;
    int right = str.Length - 1;
    while (left < right)
    {
        if (str[left] != str[right])
        {
            return false;
        }
        left++;
        right--;
    }
    return true;
}

数组中的最大值和最小值：通过迭代找出数组中的最大值和最小值。

public static Tuple<int, int> FindMaxMin(int[] arr)
{
    int min = arr[0];
    int max = arr[0];
    for (int i = 1; i < arr.Length; i++)
    {
        if (arr[i] < min)
        {
            min = arr[i];
        }
        else if (arr[i] > max)
        {
            max = arr[i];
        }
    }
    return Tuple.Create(max, min);
}

素数检查器：通过迭代判断一个数字是否为素数。

public static bool IsPrime(int number)
{
    if (number <= 1) return false;
    for (int i = 2; i * i <= number; i++)
    {
        if (number % i == 0) return false;
    }
    return true;
}

字符串中的最长无重复子串：通过迭代和哈希集合找到一个字符串中的最长无重复字符的子串长度。

public static int LengthOfLongestSubstring(string s)
{
    Dictionary<char, int> lastSeen = new Dictionary<char, int>();
    int start = 0;
    int maxLength = 0;

    for (int i = 0; i < s.Length; i++)
    {
        if (lastSeen.ContainsKey(s[i]) && lastSeen[s[i]] >= start)
        {
            start = lastSeen[s[i]] + 1;
        }
        lastSeen[s[i]] = i;
        maxLength = Math.Max(maxLength, i - start + 1);
    }

    return maxLength;
}