如何用C写阶乘？

我需要输入这个方程，其中有一个阶乘。我想知道C中的某些东西的阶乘是否有类似于*的乘法或pow（1,3）

term = pow(-1, K) * pow(x, 2K)/(2K)

---

factorial将用于最后2K。

factorial没有预定义的函数，但可以按如下方式递归实现

int factorial( int a )
{
    if ( 0 == a )
        return 1;
    else
        return a * factorial( a - 1 );
}

int factorial( int a )
{
    return 0 == a ? 1 : ( a * factorial( a - 1 ) );
}

int factorial( int a )
{
    int Result = 1;
    for ( int i = a; i > 0; Result *= i, i-- );
    return Result;
}

喜欢

？

操作符的人可以实现以下功能

int factorial( int a )
{
    if ( 0 == a )
        return 1;
    else
        return a * factorial( a - 1 );
}

int factorial( int a )
{
    return 0 == a ? 1 : ( a * factorial( a - 1 ) );
}

int factorial( int a )
{
    int Result = 1;
    for ( int i = a; i > 0; Result *= i, i-- );
    return Result;
}

如果需要一个非递归公式，则可以按如下方式实现

int factorial( int a )
{
    if ( 0 == a )
        return 1;
    else
        return a * factorial( a - 1 );
}

int factorial( int a )
{
    return 0 == a ? 1 : ( a * factorial( a - 1 ) );
}

int factorial( int a )
{
    int Result = 1;
    for ( int i = a; i > 0; Result *= i, i-- );
    return Result;
}

---

如果由于某种原因，递归函数让您摸不着头脑，您也可以在不使用递归的情况下实现它：

/* calculate n factorial */
unsigned long long nfact (int n)
{
    if (n <= 1) return 1;

    unsigned long long s = n;

    while (--n)
        s *= n;

    return s;
}

/*计算n阶乘*/
无符号长nfact（整数n）
{
如果（n）
包含上述代码并调用此方法以获取数字的阶乘。
很少需要计算阶乘的函数。阶乘增长如此之快，以至于一个查找表足以满足计算不会溢出的少数值。如果在循环中计算项，则可以避免使用accum计算阶乘在整个学期中，都是一个分析者

K = 0;
term = 1;

while (K<N) {

   /* use term */
   do_something_with(term);

   /* update term for new value of K */
   K += 1;
   term = -term * x*x / (2*K*(2*K-1));
}

K=0；
术语=1；
虽然（K阶乘很容易计算，但毕竟n！只是所有数字到n的乘积。但有一个实际问题：。一个32位整数可以容纳12！，一个64位整数可以容纳20

根据级数收敛的方式，可能会溢出有效范围

对于类似于您的近似级数，通常最好找到一种方法，用项k来表示项k− 1.就你而言：

    term = pow(-1, k) * pow(x, 2*k) / fact(2*k)

您可以将一个术语表示为

    term[k + 1] = -term[k] * pow(x, 2) / ((2*k - 1) * (2*k - 2))

您的系列将变成：

    double f(double x)
    {
        double term = 1.0;
        double res = term;
        int k = 0;

        while (k < 100) {
            double old = res;

            term = -term * (x / (2*k + 1)) * (x / (2*k + 2));
            res += term;

            if (res == old) break;
            k++;
        }

        return res;
    }

双f（双x）
{
双项=1.0；
双res=期限；
int k=0；
而（k<100）{
双倍旧=res；
术语=-术语*（x/（2*k+1））*（x/（2*k+2））；
res+=期限；
如果（res==旧）中断；
k++；
}
返回res；
}

此函数最多使用100次迭代来计算余弦。当该项对结果没有影响时，它将停止。实际上，它只需大约10次迭代就可以得到结果，因此在这种情况下，常规的阶乘计算将足够精确。不过，反复计算它们是浪费时间的。
我认为使用re对于这个问题，诅咒是一个很好的方法来开始递归并理解它的工作方式，但是它不够有效，因为你每次都在调用一个函数。如果你想知道为什么，做一个测试，看看它需要多长时间。虽然我应该说，迭代方法也没有明显的更好

来自Steve McConnell完成的代码：

不要对阶乘或斐波那契数使用递归

计算机科学教科书的一个问题是它们呈现的是愚蠢的
递归的例子。典型的例子是计算阶乘
递归是一个强大的工具，而且
在这两种情况下使用它都是愚蠢的
为我工作的人用递归计算阶乘，我会雇佣他
其他人

所以，在浏览这里发布的递归版本时，请记住这一点。现在，如何编写一个

基本上，当数字小于1时，有一个基本情况和一个一般递归情况。在递归函数中，通常有一个基本情况和一个递归情况。对于阶乘，它看起来像这样：

int factorial_rec(int number)
{
    if (number == 0)
    {
        return 1;
    }else
    {
        return number * factorial_rec(number - 1);
    }
}

使用递归算法查找给定数字的阶乘的代码如下所示：

#include<stdio.h>
int fact(int n)
{
    if(!n)
        return 1;
    else
        return (n*fact(n-1));
}
void main()
{
    int n;
    printf("Enter number : ");
    scanf("%d",&n);
    printf("\nFactorial of %d is : %d",n,fact(n));
}

#包括
整数事实（整数n）
{
如果（！n）
返回1；
其他的
返回（n*事实（n-1））；
}
void main（）
{
int n；
printf（“输入编号：”）；
scanf（“%d”和“&n”）；
printf（“\n%d的工厂是：%d”，n，事实（n））；
}
#包括
长阶乘（整数n）
{  
如果（n==0）
返回1；
其他的
收益率（n*阶乘（n-1））；
}  
void main（）
{  
整数；
长期事实；
printf（“输入一个数字：”）；
scanf（“%d”和编号）；
事实=阶乘（数字）；
printf（“%d的阶乘是%ld\n”，数字，事实）；
返回0；
}  
没有内置的标准函数，您需要编写自己的阶乘实现。您能告诉我如何做到这一点吗？一种方法是：使用
for
从
1
到
2K
的循环，并将term
term
除以每个数字。它通常作为递归函数实现。您可以可能在这个网站上搜索
factorial
，并给出一些例子。factorial很快就会溢出标准整数类型，因此最好用term（k-1）来表示term（k）。这种策略还应该避免对
pow
的两个调用。我认为，如果你把
放在（你知道，你是100%对的。改变了。谢谢你！。现在它的状态很好。
：）
仔细看
n--
，它不完全是
n--
它是
--n
减少的原因。啊，是的。你是对的。我没有注意到
s=n；
）
正确的方向如您所说……感谢您提供这段代码片段，它可能会提供一些有限的、即时的帮助。通过说明为什么这是一个很好的问题解决方案，A将极大地提高其长期价值，并使其对未来有其他类似问题的读者更有用。请您的答案添加一些解释，包括你所做的假设。