String 我们可以说下面的算法的复杂度正好是O（lgn）

我编写了一个函数来将整数转换为字符串。我们可以说这个算法的复杂度正好是O（lgn）？因为输入字符串中的字符数正好是lgn+1

char* int_to_str(int n)
{
    int size = 0;
    bool is_neg = false;
    int m = n;
    if (n < 0)
    {
        is_neg = true;
        m = n - (n << 1);
    }
    int k = m;
    while(k > 0)
    {
        k /= 10;
        ++size;
    }
    char* out;
    if(is_neg)
    {
        out = new char[++size];
    }
    else
    {
        out = new char[size];
    }
    int i = size;
    out[i] = '\0';
    while(m > 0 && i >= 0)
    {
        out[--i] = (char)((m % 10) + '0');
        m /= 10;        
    }
    if(is_neg)
    {
        out[0] = '-';
    }
    return out;
}

char*int\u to\u str（int n）
{
int size=0；
bool是_neg=false；
int m=n；
if（n<0）
{
is_neg=真；
m=n-（n0）
{
k/=10；
++大小；
}
字符*输出；
如果（是负的）
{
out=新字符[++大小]；
}
其他的
{
out=新字符[大小]；
}
int i=大小；
out[i]='\0'；
而（m>0&&i>=0）
{
out[--i]=（字符）（（m%10）+“0”）；
m/=10；
}
如果（是负的）
{
out[0]='-'；
}
返回；
}

我知道你的问题是关于

O（lg（N））

vs

lg（N）+1

你需要回到过去

它指出，对于足够大的参数值，任何函数都是运行时间的上限，并乘以合适的常数，都可以使用

您可以轻松检查

lg（N）+1

是否为

O（lg（N））

或

O（log（N））

[base 10]或

O（ln（N））

[base

e

]或

O（lg（N）+1

或

O（lg（N）/4+1000/N）

或

O（Hn

你也有
lg（N）+1
是
O（N）
或
O（N^2）
或
O（N！）
…但这些界限并不严格。
O（lg（N））与O（lg（N）+1相同，只是常数不同

g（x）=O（f（x））意味着存在常数k，x0，使得g（x）=x0

假设h（x）=O（f（x）+1，这意味着存在常数k1，x1
h（x）=x1

或h（x）=x1

如果g（x）单调递增，如果我们认为h（x1）-g（x0）可以大于k1，我们可以说g（x）=O（f（x）+1

由于lg（N）单调增加且没有上界，我们可以断言O（lg（N））和O（lg（N）+）是相同的，一个界并不比另一个界强。
该算法是线性的，O（d），其中d是用于n的位数。复杂性总是以输入大小而不是输入值来衡量。整数的大小是它的位长度，如果使用大整数，它会变得更明显。@LutzL：不一定，它可以用任何东西来衡量。想想欧几里德算法的复杂性，它是根据输入值而不是输入大小（通常
O（1）
！）。输出大小也可以发挥作用。还有许多其他的例子。如果你想比较不同算法的复杂度类别，唯一的统一原则是输入大小与运行时间。我认为在这种情况下，欧几里德算法的复杂度，特别是大整数变量和更有效的变量，如Lehmers algorithm总是以输入的数字或位来表示。当然，输出的大小给出了复杂度的下限，因为它的每一位都必须在算法期间写入。