Algorithm 哪个算法函数的增长更快，O（n^2）还是O（n^2*log（n）），为什么？

我对函数（n^2）和（（n^2）*log（n））应用了n的随机值，它们是1,2,4,8,16,32和64。n^2的值高于（（n^2）*log（n））的值，但在某些情况下（（n^2）*log（n））的值超过了（n^2）的值。数值表如下所示：

      n     n^2       (n^2 *log(n))
      1     1          0
      2     4          1.2
      4     16         9.6
      8     64         57.79
      16    256        308.25
      32    1156       1541.27
      64    4096       7398.11

---

从上表可以看出，哪个算法函数的增长速度更快？为什么？

如果

log

是以10为底的对数，那么

log（10）=1

，即

n^2*log（n）>n^2

表示

n>10

。对于所有其他对数基数也是如此，即

n^2*log（n，b）>n^2

对于

n>b

如果

log（n，b）

是

n

与底

b
的对数，如果
log
是以10为底的对数，那么
log（10）=1
，即
n^2*log（n）
对于
10。对于所有其他对数基数也是如此，即
n>b的
n^2*log（n，b）>n^2
，如果
log（n，b）
是
n
的对数，则
b
的复杂性分析通常侧重于渐近行为，因为我们在进行大型计算时通常只关心性能（对小问题规模的低效计算不是典型的研究对象）

考虑到这一点，小输入的行为通常被忽略，我们说一个函数是从上面渐近绑定的（f=O（g）），这意味着f的增长速度不超过g，如果最终总是这样的话

很明显，n^2 log（n）最终总是大于n^2，因为log（n）最终假定任何对数基数的值大于1，在这之后，点n^2 log（n）总是大于n^2。的确，对于小于对数底的值，它的值较小，但此类输入大小的数量很少。
复杂性分析通常侧重于渐近行为，因为我们在进行大型计算时通常只关心性能（对小问题规模的低效计算不是典型的研究对象）

考虑到这一点，小输入的行为通常被忽略，我们说一个函数是从上面渐近绑定的（f=O（g）），这意味着f的增长速度不超过g，如果最终总是这样的话

很明显，n^2 log（n）最终总是大于n^2，因为log（n）最终假定任何对数基数的值大于1，在这之后，点n^2 log（n）总是大于n^2。的确，对于小于对数底的值，它有一个较小的值，但这样的输入大小将只有少量。
对于一些较小的值
n^2
比
n^2*logn
快的原因是logb（n）<1表示所有n8
和
16
之间

  n  n^2  logn  n^2*logn
------------------------
  1    1  0.00     0.00
  2    4  0.30     1.20
  4   16  0.60     9.63
  8   64  0.90    57.80  ^^^ logn < 1
 16  256  1.20   308.25  vvv logn > 1
 32 1024  1.51  1541.27
 64 4096  1.81  7398.11

n^2 logn^2*logn
------------------------
1    1  0.00     0.00
2    4  0.30     1.20
4   16  0.60     9.63
8 64 0.90 57.80^^^^^^^ logn<1
16 256 1.20 308.25 vvv日志>1
32 1024  1.51  1541.27
64 4096  1.81  7398.11

在那之后，
logn
比1大并不断增长（尽管越来越慢），这意味着对于所有更高的值，
n^2*logn
比
n^2
更大、增长更快。对于
n的一些小值，它更小与此无关，就像对于一些小输入，具有恒定复杂度的函数可能比指数函数慢一样。
一些小值的原因是什么^2
比
n^2*logn
是logb（n）<1表示所有n8
和
16
之间

  n  n^2  logn  n^2*logn
------------------------
  1    1  0.00     0.00
  2    4  0.30     1.20
  4   16  0.60     9.63
  8   64  0.90    57.80  ^^^ logn < 1
 16  256  1.20   308.25  vvv logn > 1
 32 1024  1.51  1541.27
 64 4096  1.81  7398.11

n^2 logn^2*logn
------------------------
1    1  0.00     0.00
2    4  0.30     1.20
4   16  0.60     9.63
8 64 0.90 57.80^^^^^^^ logn<1
16 256 1.20 308.25 vvv日志>1
32 1024  1.51  1541.27
64 4096  1.81  7398.11

在那之后，
logn
比1大并不断增长（尽管越来越慢），这意味着对于所有更高的值，
n^2*logn
比
n^2
更大、增长更快。对于一些较小的
n
值，它更小是不相关的，就像对于一些较小的输入，具有恒定复杂性的函数可能比指数函数慢一样。
我们想知道的是：will
log（n）
是否大于1

如果我们将
O（n²）
与
O（n²log（n））
进行比较，我们需要知道
log（n）
是大于还是小于1。正如你所说，我认为
log（n）
是以2为底的对数

log(n) > 1   
n > 2^1
n > 2

在
n>2
之后，
log（n）>1
，这意味着
O（n²）
对于所有
n>2
我们想知道的是：
log（n）
会大于1吗

如果我们将
O（n²）
与
O（n²log（n））
进行比较，我们需要知道
log（n）
是大于还是小于1。正如你所说，我认为
log（n）
是以2为底的对数

log(n) > 1   
n > 2^1
n > 2

在
n>2
之后，
log（n）>1
，这意味着
O（n²）
对于所有
n>2
可以通过限制这两个来显示：

lim_{n \to \infty} n^2 / (n^2 * log(n)) = lim_{n \to \infty} 1 / log(n) = 0

最后一步是因为
log
函数是严格递增函数。因此，根据极限结果，
这意味着
n^2=o（n^2*log（n））
（小oh）和
n^2*log（n）
的增长速度比
n^2
要快。您可以通过限制这两个来显示：

lim_{n \to \infty} n^2 / (n^2 * log(n)) = lim_{n \to \infty} 1 / log(n) = 0

最后一步是因为
log
函数是严格递增函数。因此，根据极限结果，
这意味着
n^2=o（n^2*log（n））
（小oh），并且
n^2*log（n）
的增长更快