Question

我正在算法类中学习Big O表示法。我刚刚在本周做了一个在线测验，我们得到了一堆代码块，我们必须选择大的O复杂度。

除了这个代码块，我得到了正确的一切：

void printPairs(int[] arrX, int[] arrY) {
    for(int i = 0; i < arrX.length; i++) {
        for(int j = 0; j < arrY.length; j++) {
            System.out.println(arrX[i] + "," + arrY[j]);
        }
    }
}

我输入O(N^2)但是我弄错了，我不知道为什么，有两个for循环？不幸的是，直到本周末我才能看到其他可用选项或正确答案。

Answer 1

如果只有一个输入，那么运行时将是 O（N²），即一个数组作为参数传递并在两个for循环中的每一个中迭代。

因为该方法有两个输入（arrX和arrY），并且在两个for循环中都使用了两个输入。

Big O运行时是 O（XY），其中X = arrX.length和Y = arrY.length。

修改正如 @Oighea 所述，仍然是二次时间算法。它只是两个变量。

Answer 2

考虑每个数组的元素数量，假设type IsValidArg<T> = T extends object ? keyof T extends never ? false : true : true; type FunctionToConstructor<T, TReturn> = T extends (a: infer A, b: infer B) => void ? IsValidArg<B> extends true ? new (p1: A, p2: B) => TReturn : IsValidArg<A> extends true ? new (p1: A) => TReturn : new () => TReturn : never; type ReplaceCtorReturn<T, TReturn> = T extends new (a: infer A, b: infer B) => void ? IsValidArg<B> extends true ? new (p1: A, p2: B) => TReturn : IsValidArg<A> extends true ? new (p1: A) => TReturn : new () => TReturn : never; type ConstructorOrDefault<T> = T extends { constructor: infer TCtor } ? TCtor : () => void; function Class(name: string): { extends<TBase extends { new(...args: any[]): any, __original: any }, T>(base: TBase, members: (b: { Super: (t: any) => TBase['__original'] }) => T & ThisType<T & InstanceType<TBase>>): T extends { constructor: infer TCtor } ? FunctionToConstructor<ConstructorOrDefault<T>, InstanceType<TBase> & Pick<T, Exclude<keyof T, 'constructor'>>> : ReplaceCtorReturn<TBase, InstanceType<TBase> & Pick<T, Exclude<keyof T, 'constructor'>>> } function Class<T>(name: string, members: T & ThisType<T>): FunctionToConstructor<ConstructorOrDefault<T>, Pick<T, Exclude<keyof T, 'constructor'>>> & { __original: T } function Class(): any { return null as any; } const Animal = Class('Animal', { sound: '', constructor(sound: string) { this.sound = sound; }, makeSound() { console.log(this.sound) } }) new Animal('').makeSound(); const Dog = Class('Dog').extends(Animal, ({ Super }) => ({ constructor(size: 'small' | 'big') { if (size === 'small') Super(this).constructor('woof') if (size === 'big') Super(this).constructor('WOOF') }, makeSound(d: number) { console.log(this.sound) }, bark() { this.makeSound() }, other() { this.bark(); } })) type Dog = InstanceType<typeof Dog> const smallDog: Dog = new Dog('small') smallDog.bark() // "woof" const bigDog = new Dog('big') bigDog.bark() // "WOOF" bigDog.bark(); bigDog.makeSound();有n个元素，arrX有m个元素。第一次迭代是在arrY上完成的，因此仅关于第一个循环将具有 O（n）的运行时间。迭代arrX的内部循环具有m个元素，其运行时间为 O（m），因为它为arrY的每个元素迭代一次，整个方法 O（nm）的最坏情况运行时。假设两个阵列具有相同长度的情况，那么特殊情况的运行时间 O（nm）， n = m ，这将使其 O （N ^ 2）

你的答案并非完全错误，但它不包括所有可能性，只有一个......

Answer 3

是的，你是对的。有2个循环。但每个循环遍历不同的数组。

因此，如果第一个数组的长度为= N ，并且如果第二个数组= M ，则最坏情况下的时间复杂度为 O （nm）的

现在，如果两个数组的大小相同，n = m，那么 O（nm ） = O（n ^ 2 ）

为什么这段带有两个for循环的代码没有O（N ^ 2）的Big O运行时？

3 个答案: