Fatal编程技术网

Algorithm 时间复杂度计算

algorithm math time-complexity

Algorithm 时间复杂度计算,algorithm,math,time-complexity,Algorithm,Math,Time Complexity,我目前正在做一些考试题，但在这一点上被卡住了。我知道快速排序算法的时间复杂度为O（nlog（n））。对于特定的输入大小，对列表进行排序的时间为4分钟。接下来的问题是，在同一个系统上，对一个两倍大小的列表进行排序需要多长时间 我已经排除了时间不是8minutes（输入大小的两倍=持续时间的两倍，非常非常错误的推理）的可能性 我做过一些工作： 在工作中 4=nlog（n） 4=log（n^n） 16=n^n 我基本上被困在这一点上了 工作B X=2nlog（2n）>>2n因为输入加倍 X=2n

我目前正在做一些考试题，但在这一点上被卡住了。我知道快速排序算法的时间复杂度为
O（nlog（n））
。对于特定的输入大小，对列表进行排序的时间为4分钟。接下来的问题是，在同一个系统上，对一个两倍大小的列表进行排序需要多长时间

我已经排除了时间不是
8
minutes（输入大小的两倍=持续时间的两倍，非常非常错误的推理）的可能性

我做过一些工作：

在工作中

  • 4=nlog（n）
  • 4=log（n^n）
  • 16=n^n
  • 我基本上被困在这一点上了
工作B

  • X=2nlog（2n）>>2n
    因为输入加倍
  • X=2n（1+log（n））
  • X=2n+2nlog（n）>>nlog（n）
    was
    4
    min
  • X=2n+2（4）=2n+8
  • 我再一次陷入了困境
      • 如果不知道n的值，就无法计算绝对时间。
      通过一些经验值来了解这一点。
      假设“k”是一次操作所用的时间

      If, n = 2, k.n.log(n) = 4   => k.2.1 = 4   => k = 2
  if n is doubled, k.2n.log(2n) = 2.4.2 => 16 minutes

If, n = 4, k.n.log(n) = 4   => k.4.2 = 4   => k = 1/2
  if n is doubled, k.2n.log(2n) = 1/2.8.3 => 12 minutes

If, n = 64, k.n.log(n) = 4   => k.64.6 = 4   => k = 1/96
  if n is doubled, k.2n.log(2n) = 1/96.128.7 => 9.33 minutes
      因此，随着n的增加，所用的时间接近时间的两倍（8分钟）

      提供的信息不完整

      证明：

      让算法复杂度为
      O（nlogn）
      。这表示所用的时间，
      t
      =
      c*nlogn

      因此，我们有以下方程式：

      • 4=c*n*logn
      • t=c*（n2）*log（n2）
        ，其中
        t
        是必需的答案
      • n2=2*n2
      变量数量=4（
      n
      ，
      n2
      ，
      t
      ，
      c
      ）
      唯一方程的数量=3
      因为我们至少需要4个方程来表示4个变量，所以提供的信息是不完整的

      我想关于这个问题首先要注意的是，考虑到对数字进行排序需要4分钟，
      n
      一定很大。例如，我只是在电脑上用快速排序对10亿个数字进行排序，只花了不到3分钟的时间。所以
      n
      大概是10亿左右（给定或取一个数量级）

      考虑到
      n
      是巨大的，对于某些常量
      c
      ，将此运行时间近似为
      c*n*lg（n）
      可能是合理的，因为运行时扩展的低阶项不应该与如此大的
      n
      太相关。如果我们将
      n
      加倍，则与原始运行时相比，我们得到以下运行时乘数：

      [Runtime(2n)] / [Runtime(n)]
[c * (2n) * lg(2n)] / [c * n * lg(n)]
2 * lg(2n) / lg(n)
2 * log_n(2n)
2 * (1 + log_n(2))
      这里，
      lg（）
      是任意基数下的对数，
      log\u n（）
      是对数基数
      n

      首先，由于我们假设
      n
      很大，一种可能的方法是将
      log\u n（2）
      近似为0，因此运行时乘数近似为2，总运行时间近似为8分钟

      或者，由于我们可能知道
      n
      在一个数量级内，另一种可能是近似于
      n
      可能值的乘数：

      • 如果
        n
        =1亿，那么我们将近似乘数为2.075，总运行时间为8.30分钟
      • 如果
        n
        =10亿，那么我们将近似乘数为2.067，总运行时间为8.27分钟
      • 如果
        n
        =100亿，那么我们将近似乘数为2.060，总运行时间为8.24分钟
      这里请注意，我们对
      n
      的近似值的巨大变化在总运行时的近似值上产生了非常小的变化

      值得注意的是，虽然这在纸面上看起来不错，但实际上，架构方面的考虑可能会导致实际运行时与我们在这里计算的运行时大不相同。例如，如果该算法在将数据大小增加一倍后引发一系列分页，那么运行时间可能会比我们在这里估计的~8分钟要高得多。

      我喜欢@Amitoj的推理，但我会将其推广

      设
      n0
      =导致运行时间为4分钟的元素数，
      n1
      =2*
      n0
      。那么我们有

      c = 4 mins / (n0 * log n0)
      我们正在努力寻找

      t = c * n1 * log n1
  = 4 mins / (n0 * log n0) * n1 * log n1
  = 4 mins * (n1 / n0) * (log n1 / log n0)

      n1/n0
      始终等于2

      当n0=>无穷大时，
      logn1/logn0
      的限制变为1

      是的，当n0变大时，t的极限是
      4分钟*2=8分钟
      除了
      Anmol Singh Jaggi
      之外，所有答案都是错误的

      首先，很容易看出，这些信息不足以得到答案。这就是为什么：

      你所需要做的就是解一个方程。如果算法的时间复杂度为O（n logn），那么第一个等式为：

      其中
      n
      在列表的大小中。如果他们想让你找出完成两倍大的算法需要多少时间，他们基本上想找到
      x
      ：

      所以基本上你需要解一个2个方程组，3个未知。它要么有0个答案（不是在我们的例子中），要么有无限多个答案

      现在你必须假设你的c1。如果c1=1，则

      将n代入第二个等式：
      x=13.5
      。13分半钟

      但是再一次，这个答案是基于c1等于1的假设，如果你有另一个常数因子，你会得到另一个答案。

      这听起来像是一个非常糟糕的考题，可能是由一个对大O符号的真正含义没有深刻理解的人写的。它有很多错误——其中很多已经在其他答案中得到了解决

      最大的问题就是这么大