O（n！）的例子？
O（n！）函数的例子（在代码中）是什么？ 它应该采取适当数量的操作来参照n来运行; 也就是说，我在问时间的复杂性。
你走了 这可能是在O(n!)时间（其中n是函数的参数O(n!)中运行的函数的最微不足道的示例：
void nFacRuntimeFunc(int n) { for(int i=0; i<n; i++) { nFacRuntimeFunc(n-1); } }
一个典型的例子是通过powershellsearch的旅行商问题 。
如果有N个城市，暴力方法将尝试对这N个城市进行每一个排列，找出哪一个是最便宜的。 现在N个城市的排列数是N! 使其成为复杂因子（ O(N!) ）。
请参阅Big O维基百科文章的常见function部分。
根据文章，通过powershellsearch解决旅行商问题 ，find未成年人扩张的决定因素都是O（n！）。
find未成年人扩大的决定因素。
这里非常好的解释。
# include <cppad/cppad.hpp> # include <cppad/speed/det_by_minor.hpp> bool det_by_minor() { bool ok = true; // dimension of the matrix size_t n = 3; // construct the determinat object CppAD::det_by_minor<double> Det(n); double a[] = { 1., 2., 3., // a[0] a[1] a[2] 3., 2., 1., // a[3] a[4] a[5] 2., 1., 2. // a[6] a[7] a[8] }; CPPAD_TEST_VECTOR<double> A(9); size_t i; for(i = 0; i < 9; i++) A[i] = a[i]; // evaluate the determinant double det = Det(A); double check; check = a[0]*(a[4]*a[8] - a[5]*a[7]) - a[1]*(a[3]*a[8] - a[5]*a[6]) + a[2]*(a[3]*a[7] - a[4]*a[6]); ok = det == check; return ok; }
代码从这里 。 你也会在那里find必要的.hpp文件。
我觉得我有点晚了，但是我发现蜗牛是O（n！）确定性algorithm的最好例子。 它基本上find一个数组的下一个排列，直到它sorting。
它看起来像这样：
template <class Iter> void snail_sort(Iter first, Iter last) { while (next_permutation(first, last)) {} }
存在的问题是NP-complete （可以在非确定性的多项式时间中validation）。 意思是如果input规模，那么你的计算需要解决的问题增加了很多。
一些NP-hard难题是： 哈密顿path问题 （ open img ）， 旅行商问题 （ open img ）
一些NP-complete问题是： 布尔可满足性问题（Sat.） （ open img ）， N-puzzle （ open img ）， 背包问题 （ open img ）， 子图同构问题 （ open img ）， 子集求和问题 （ open img ） 集合问题 （ open img ）， 顶点覆盖问题 （ open img ）， 独立集问题 （ open img ）， 支配集问题 （ open img ）， 图着色问题 （ open img ），
来源： 链接1 ， 链接2
来源： 链接
最简单的例子:)
伪代码：
input N calculate N! and store the value in a vaiable NFac - this operation is o(N) loop from 1 to NFac and output the letter 'z' - this is O(N!)
你去:)
作为一个真实的例子 – 如何产生一组项目的所有排列？
printf("Hello World");
是的，这是O（n！）。 如果您认为不是，我build议您阅读BigOh的定义。
我只是添加了这个答案，因为烦人的习惯，人们不得不总是使用BigOh，而不pipe它们的实际含义如何。
例如，我很确定这个问题打算问Theta（n！），至less是cn！ 步骤和不超过Cn！ 步骤为一些常数C，C> 0，但select使用O（n！）来代替。
另一个例子： Quicksort is O(n^2) in the worst case ，而在技术上是正确的（甚至Quicksort is O(n^2) in the worst case ，heapsort是O（n ^ 2）！），他们实际上的意思是Quicksort is Omega(n^2) in the worst case 。
在维基百科
通过powershellsearch解决旅行商问题; find未成年人扩张的决定因素。
http://en.wikipedia.org/wiki/Big_O_notation#Orders_of_common_functions
计算给定数组的所有排列的algorithm都是O（N！）。
在C＃
在空间复杂性中，这不是O（N！）吗？ 因为C＃中的string是不可变的。
string reverseString(string orgString) { string reversedString = String.Empty; for (int i = 0; i < orgString.Length; i++) { reversedString += orgString[i]; } return reversedString; }
Bogosort是我遇到的唯一的“官方”企业，进入O（n！）区域。 但是它不是一个保证的O（n！），因为它本质上是随机的。
你可能学习matrix的行列式（如果你使用线性代数）的recursion方法需要O（n！）时间。 虽然我不特别想编码，所有的一切。
@clocksmith你是绝对正确的。 这不是计算n !. 也不是O（n！）。 我跑它收集了下表中的数据。 请比较第2栏和第3栏。 （#nF是调用nFacRuntimeFunc的次数）
n＃nF n！
0 0 1 1 1 1 2 4 2 3 15 6 4 65 24 5 325 120 6 1956 720 7 13699 5040
很明显，如果performance比O（n！）糟得多。 以下是计算n的示例代码！ recursion。 你会注意到它的O（n）顺序。
int Factorial(int n) { if (n == 1) return 1; else return n * Factorial(n-1); }
你是正确的recursion调用应该采取正确的n！ 时间。 这里是一个代码，为n个不同的值testing阶乘时间。 内循环运行n！ 时间为j的不同值，所以内循环的复杂度是大O（n！）
public static void NFactorialRuntime(int n) { Console.WriteLine(" N Fn N!"); for (int i = 1; i <= n; i++) // This loop is just to test n different values { int f = Fact(i); for (int j = 1; j <= f; j++) // This is Factorial times { ++x; } Console.WriteLine(" {0} {1} {2}", i, x, f); x = 0; } }
这里是n = 5的testing结果，它迭代了正确的阶乘时间。
N Fn N! 1 1 1 2 2 2 3 6 6 4 24 24 5 120 120
具有时间复杂度的精确函数n！
// Big O(n!) public static void NFactorialRuntime(int n) { for (int j = 1; j <= Fact(i); j++) { ++x; } Console.WriteLine(" {0} {1} {2}", i, x, f); }
