Fatal编程技术网
  • java/
  • Java O（n logn）时间复杂度算法？

Java O（n logn）时间复杂度算法？

java algorithm time big-o

Java O（n logn）时间复杂度算法？,java,algorithm,time,big-o,Java,Algorithm,Time,Big O,我创建这个算法是为了找到3个数字之间的最佳交易。它通过该计划，找到出售、购买和从股票中获利的最佳时机。我需要解释使用的算法，以及时间复杂度是如何为O（n logn），但我很难确定这一点。我希望有人能解释O（n logn）并将其与我的方法联系起来 以下是我的方法： public static Trade bestTrade(int[] a) { int lowest = a[0]; int lowestIndex = 0; int highest = a

我创建这个算法是为了找到3个数字之间的最佳交易。它通过该计划，找到出售、购买和从股票中获利的最佳时机。我需要解释使用的算法，以及时间复杂度是如何为O（n logn），但我很难确定这一点。我希望有人能解释O（n logn）并将其与我的方法联系起来

以下是我的方法：

public static Trade bestTrade(int[] a) 
   {
      int lowest = a[0];
      int lowestIndex = 0;
      int highest = a[a.length - 1];
      int highestIndex = a.length - 1;
      int profit = 0;

      for(int i = 1; i < a.length; i++) 
      {
         if (a[i] < lowest && i < highestIndex) 
         {
            lowest = a[i];
            lowestIndex = i;
         }  
      }

      for(int i = a.length - 2; i >= 0; i--) 
      {
         if (a[i] > highest && i > lowestIndex) 
         {  
            highest = a[i];   
            highestIndex = i;
         }  
      }

      for(int i = 1; i < a.length; i++) 
      {
         if (a[i] < lowest && i < highestIndex) 
         {   
            lowest = a[i];   
            lowestIndex = i;
         }  
      }

      if (highestIndex > lowestIndex) 
      {
         profit = highest - lowest;
         return new Trade(lowestIndex, highestIndex, profit);
      }

      return new Trade(lowestIndex, highestIndex, profit);
   }

}

公共静态交易最佳交易（int[]a）
{
int最低=a[0]；
int-lowestinex=0；
int最高=a[a.长度-1]；
int highestIndex=a.length-1；
国际利润=0；
for（int i=1；i=0；i--）
{
如果（a[i]>最高和&i>最低索引）
{  
最高=a[i]；
高指数=i；
}  
}
for（int i=1；i最低索引）
{
利润=最高-最低；
返回新交易（低指数、高指数、利润）；
}
返回新交易（低指数、高指数、利润）；
}
}
此函数为O（n），优于O（n log n）。 一般来说，您只需查看循环，因为没有嵌套的循环，并且只有穿过a的所有元素的循环。函数被视为n。

复杂度为O（n），其中n是数组a的长度

在a上循环3次，因此运行时间大约为3n，因此顺序为n:O（n）。

试着自己找到答案。这在将来会有很大帮助。而且这看起来像一个O（N），我不知道为什么你确信它是O（NlogN）

这个链接可能有用，

O（n）

它与a.长度的数量成正比。每次运行for函数时，它都会遍历每天的数据。如果有一种方法，其中进程数增加的幅度大于纯数（嵌套fors），那么它可以是O（n logn）或O（n^2）。但在这种情况下，很明显它只是n中的一个大O。

乍一看，它实际上是O（3n），它等同于O（n）。在我看来是O（n）。所有循环都是线性的。没有递归。所以为了使时间复杂度达到O（n logn），我需要组合for循环？抱歉，这是一种新的算法。@O（nlogn）算法通常是涉及递归的分治排序算法。嵌套循环通常会导致n平方运行时。所以我需要一组嵌套的FOR来创建O（n logn）复杂度@AlexGO（n log n）看起来是这样的：for（int i=1；i