Algorithm 如何用大O表示法计算后续数组双查找的时间复杂度

以下算法的时间复杂度是多少？？有人能帮忙吗

public class Util
{

    public static int GetDistance(int[] array)
    {
        //Find the max seperation of two same numbers inside an array for example 
        // {1,2,4,1,5,9,0,4,15,1,2} should return 9 ( position of '1' at 9th and 0th location)

        int N = array.Length;
        int maxDistance=0;
        for (int i = 0; i < N; i++)
        {
            for (int j = (N-1); j > i; j--) 
             {
                 if (array[j]==array[i])   
                    if(maxDistance < (j-i))
                        maxDistance = j- i;
             }//End of inner for

        }//End of for
        System.Console.WriteLine("maxDistance " + maxDistance);
        return maxDistance ;
    } //End of Function

} //End of Class

公共类Util
{
公共静态int GetDistance（int[]数组）
{
//例如，查找数组中两个相同数字的最大间距
//{1,2,4,1,5,9,0,4,15,1,2}应返回9（第9和第0位置的“1”位置）
int N=数组长度；
int最大距离=0；
对于（int i=0；ii；j--）
{
if（数组[j]==数组[i]）
如果（最大距离<（j-i））
最大距离=j-i；
}//内螺纹端部
}//结束
系统控制台写入线（“maxDistance”+maxDistance）；
返回最大距离；
}//函数结束
}//下课

查看内部循环（内部循环中的操作需要恒定的时间）。内部循环被精确地执行

N-1-i

次

然后，外部循环被精确地执行

N次

，值增加

i

。总工作量包括

(N-1) + (N-2) + (N-3) + ... + 1

内体的执行。这个总和是一个三角形的数字，证明它等于也没什么大不了的

(N-1).N / 2

---

这是O（N²）。

您查看内部循环（内部循环中的操作需要恒定的时间）。内部循环被精确地执行

N-1-i

次

然后，外部循环被精确地执行

N次

，值增加

i

。总工作量包括

(N-1) + (N-2) + (N-3) + ... + 1

内体的执行。这个总和是一个三角形的数字，证明它等于也没什么大不了的

(N-1).N / 2

---

这是O（N²）。

您有两个for循环，循环次数为N次（第二个也是受数字N的影响，表示N越大，迭代次数越大）

在循环内部，操作为O（1）

---

所以总共有O（1）*O（N^2）=O（N^2）

有两个for循环，循环迭代N次（第二个也是受数字N的影响，意思是N越大，迭代次数越大）

在循环内部，操作为O（1）

---

所以你总共有O（1）*O（N^2）=O（N^2）

这是否意味着O（N²）的时间复杂度表示与O（（N²-N）/2）相同？当然。对于大N，N与N²相比是可忽略的。这是否意味着O（N²）的时间复杂度表示与O（（N²-N）/2）相同？当然。对于大N，N与N²相比是可忽略的。这是否意味着O（N²）的时间复杂度表示与O（（N²-N）/2）相同？这意味着big-O表示法不是一个好的比较参数，因为以下循环也将具有相同的时间复杂度，但对于（int i=0；i=0；j--）//反向迭代完整数组{if（array[j]==array[i]）如果（maxDistance<（j-i））maxDistance=j-i；}//End of internal for}//End of forBig-O可以很好地比较它的作用，即算法的总体性能，特别是对大N的性能。如果您正在推理某些代码的实际性能，你必须分析它。如果输入N对于实际输入数据来说不够大，并且当O（N）代码的复杂性远远超过第一个代码中N^2的价格时，很容易出现O（N^2）优于O（N）的情况。例如，当你只使用大约1E6整数时，在C++中随机插入和删除，向量比双链表（O（n））更快（O（n 2）），因为每次循环内圈不迭代n次，内环不迭代n次。我同意这一点，但问题是它不是一个常数时间的迭代，它总是受到N的影响。如果你有一个更大的N，内部循环迭代总是更大。在big-O注释中，如果k是常数，则O（kN）=O（N）。所以内环是O（N）。这是否意味着O（N²）的时间复杂度表示与O（（N²-N）/2）相同？这意味着big-O表示法不是一个好的比较参数，因为以下循环也将具有相同的时间复杂度，但对于（int i=0；i=0；j--）//反向迭代完整数组{if（array[j]==array[i]）如果（maxDistance<（j-i））maxDistance=j-i；}//End of internal for}//End of forBig-O可以很好地比较它的作用，即算法的总体性能，特别是对大N的性能。如果您正在推理某些代码的实际性能，你必须分析它。如果输入N对于实际输入数据来说不够大，并且当O（N）代码的复杂性远远超过第一个代码中N^2的价格时，很容易出现O（N^2）优于O（N）的情况。例如，当你只使用大约1E6整数时，在C++中随机插入和删除，向量比双链表（O（n））更快（O（n 2）），因为每次循环内圈不迭代n次，内环不迭代n次。我同意这一点，但问题是它不是一个常数时间的迭代，它总是受到N的影响。如果你有一个更大的N，内部循环迭代总是更大。在big-O注释中，如果k是常数，则O（kN）=O（N）。所以内环是O（N）。