Java 如何计算此算法的大O？

我想找到method1的大O

public static void method1(int[] array, int n)
{
    for (int index = 0; index < n - 1; index++)
    {
        int mark = privateMethod1(array, index, n - 1);
        int temp = array[index];
        array[index] = array[mark];
        array[mark] = temp;
    } // end for
} // end method1

public static int privateMethod1(int[] array, int first, int last)
{
    int min = array[first];
    int indexOfMin = first;
    for (int index = first + 1; index <= last; index++)
    {
        if (array[index] < min)
        {
            min = array[index];
            indexOfMin = index;
        } // end if
    } // end for
    return indexOfMin;
} // end privateMethod1

publicstaticvoidmethod1（int[]数组，int n）
{
对于（int-index=0；index
不，你错了。在计算复杂度时，你需要关心其他函数调用。
privateMethod1
在
O（n）
时间中运行，因为在最坏的情况下
first
将是
0
，而
last
始终是
n-1
。因此，你的整个循环，即
method1
在
O（n^2）中运行
time.
在分析算法运行时间时，只有以恒定时间运行的操作，
O（1）
，才能被视为基本操作；在这种特定情况下，为算法找到一个渐近上界（大O表示法）。方法
privateMethod1
的
循环中的
迭代次数取决于
方法1
中的
索引
（其本身取决于
n
）以及
n
，并且显然不是以恒定时间运行的

因此，我们需要在算法的Big-O分析中包含
privateMethod1
。我们将把所有其他操作（如赋值和
if
语句）视为基本操作

在我们的分析中被视为基本操作：

/* in 'method1' */
int temp = array[index];
array[index] = array[mark];
array[mark] = temp;

/* in 'privateMethod1' */
int min = array[first];
int indexOfMin = first;

//...

if (array[index] < min)
{
    min = array[index];
    indexOfMin = index;
}

“方法1”中的
/**/
int temp=数组[索引]；
数组[索引]=数组[标记]；
数组[标记]=温度；
/*在“privateMethod1”中*/
int min=数组[第一个]；
int indexOfMin=第一个；
//...
if（数组[索引]


清除此项后，您可以使用Sigma表示法分析算法：
method1
中的外和描述
for
循环，而
privateMethod1
中的内循环描述
for
循环，而
1
概括了
for
内循环中所有基本操作的“成本”


因此，算法
method1
的渐近上界是
O（n^2）
不，当在算法中调用其他函数时，您一定要考虑它们的运行时间。哦，好的。谢谢您让我知道。谢谢您的回答。我还有另一个问题。在这种情况下，method1中的基本操作是什么？是对privateMethod的函数调用还是这是赋值运算吗？我的意思是，在计算大O时，哪个更重要？还有，你怎么说在最坏的情况下，
first
将是0？我的意思是
first
取决于方法1中的索引值，因为索引必须从0到（n-1）进行迭代，可能没有最坏或最好的情况，对吗？@rohitkrishna094函数调用和赋值都是基本操作，它们都采用
O（1）
time。函数调用通常意味着创建函数堆栈帧、复制参数和返回操作。这些与执行语句（即函数体）无关。对
privateMethod1
的第一次调用将具有
first=0
。在这种情况下，函数内的循环运行次数最多，即因此，显然这是最糟糕的情况。