Java system.out.println的时间复杂度

在我的算法课程中，我被告知了不同的事情，我想知道是否可以得到关于Java的System.out.println（）命令的时间复杂性的明确答案

例如，以下关于N的时间复杂度是多少

String stringy = "";
while(stringy.length() < N) {
    System.out.println(stringy);
    stringy += "X";
}

stringy=“”；
while（stringy.length（）

---

谢谢你帮助新来的家伙

这段代码的时间复杂度是O（N*N），因为它是一个N次循环。我不知道有人告诉过你什么，但打印它的时间复杂性并不比Java中的O（N）更糟糕

在您的代码中，您在每行中添加“X”，因此您的打印将是：

X
XX
XXX
XXXX
XXXXX
XXXXXX
.
.
.

因此，它的复杂性计算为，我们得到：

(1+N)*N/2=O(N^2)

要了解命令的工作方式，请阅读或：

人们普遍认为SOP的性能很差。当我们 深入分析，调用的顺序类似于println->print-> write（）+换行符（）。此序列流是 Sun/Oracle JDK。write（）和newLine（）都包含同步的 块同步有一点开销，但比这还要多 向缓冲区添加字符和打印的成本很高

当我们运行性能分析时，运行多个SOP和 记录时间，执行持续时间按比例增加。 当打印超过50个字符并打印时，性能会下降 超过50000行

这完全取决于我们使用它的场景。不管是什么情况，你都要做 不使用System.out.println记录到标准输出

---

System.out.println（stringy）的时间复杂度命令

你基本上是指上面代码片段的时间复杂度。看，时间复杂度与一个特定的代码或语言并不特别相关，它基本上是指理论上代码行将花费多少时间。这通常取决于两到三件事：


输入的大小
多项式次数（在求解多项式方程的情况下）

现在，在代码的这一部分：

String stringy = "";
while(stringy.length() < N) {// the loop will execute in order of N times 
    System.out.println(stringy);//println will execute in order of N times too as in printing each character 
    stringy += "X";
}

stringy=“”；
而（stringy.length（）

这显然取决于输入的大小，当然是字符串的长度。
首先，while循环的执行量略小于N（因为条件
stringy.length（）
使其
此代码的复杂性为
O（N^2）
。它循环N次，因为
System.out.println
必须打印每个字符，每次迭代打印0到N个字符，平均N/2，您删除常量N*N=N^2。同样，添加到字符串会导致复制整个字符串（字符串在Java中是不可变的，因此任何更改都意味着必须将整个字符串复制到一个新字符串中）。这是另一个线性操作。因此，
n*（n/2+n/2）
仍然是二次顺序-
O（n^2）

stringy=“”；
而（stringy.length（）
时间复杂度告诉您，每增加一个输入大小，您的算法需要做多少工作，给定或获取一些常数系数

所以O（2N）的上界复杂性等于复杂性O（23587N），因为这里的实际定义是


表示系数可以是任何数字，无论其大小如何，只要它相对于输入的大小是固定的

因为您没有在循环中使用“N”，您只是在字符串中添加了一个字符，每次迭代的工作量等于您有多少次迭代->O（N）

如果您有“stringy+=stringy；”，那么它将是O（N^2），因为每次迭代您都将要做的工作量加倍

**注

我假设system.out.print是一个原子语句，即它将所有字符作为单个动作打印。如果它单独打印每个字符，那么它的O（N^2）…
可以在这里找到一个很好的答案：

其主要思想是打印字符串实际上是将其复制到stdout，我们知道字符串的副本是o（n）

第二部分说，您可以尝试多次打印：
-一个字符
-非常大的绳子
你会看到时间差！！（如果打印是o（1），你就不会）
我运行了一个基本的python程序来检查python中print语句的时间复杂度，以确定要打印的可变字符数。代码如下-

import time

def current_milli_time():
    return round(time.time() * 1000)

=====================================

startTime1 = current_milli_time()

for i in range(10000):
    print("a", end="")

endTime1 = current_milli_time()

=====================================

startTime2 = current_milli_time()

for i in range(10000):
    print("ab", end="")

endTime2 = current_milli_time()

=====================================

startTime3 = current_milli_time()

for i in range(10000):
    print("abc", end="")

endTime3 = current_milli_time()

=====================================

print("\nTime(ms) for first case: ", endTime1 - startTime1)
print("Time(ms) for second case: ", endTime2 - startTime2)
print("Time(ms) for second case: ", endTime3 - startTime3)


我们可以看到，在第一种情况下，我们只打印了“a”，在第二种情况下，我们打印了“ab”，在第三种情况下，我们打印了“abc”，时间复杂度随字符数线性增加

因此，可以说，对于每种语言，print语句都需要O（lengthOfString）时间。
如果N大于0，则会有一个无限循环。
+=
就是O（无限）。函数不会完成。它不是一个无限循环。这些操作的时间复杂度是O（N^2）。
+=
是O（N）你这样做了N次。我不是在乞求rep或任何东西，但是你选择了一个非常不正确的答案。它有两个非常不正确的假设，特别是它如何处理
+=
。不知道Name的答案中有关于System.out.println的实际复杂性的好信息。因为运行
p所需的时间rintln
也是线性的，在线性循环中有一个线性操作，这使得运行时是二次的
import time

def current_milli_time():
    return round(time.time() * 1000)

=====================================

startTime1 = current_milli_time()

for i in range(10000):
    print("a", end="")

endTime1 = current_milli_time()

=====================================

startTime2 = current_milli_time()

for i in range(10000):
    print("ab", end="")

endTime2 = current_milli_time()

=====================================

startTime3 = current_milli_time()

for i in range(10000):
    print("abc", end="")

endTime3 = current_milli_time()

=====================================

print("\nTime(ms) for first case: ", endTime1 - startTime1)
print("Time(ms) for second case: ", endTime2 - startTime2)
print("Time(ms) for second case: ", endTime3 - startTime3)