Java 大O-O（log（n））代码示例

与大O符号一样，“O（1）”可以描述以下代码：

O(1):

    for (int i = 0; i < 10; i++) {
        // do stuff 
        a[i] = INT;
    }

O(n):

    for (int i = 0; i < n; i++) {
        // do stuff 
        a[i] = INT;
    }

O(n^2):
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            // do stuff
            a[i][j] = INT;
        }
    }

O（1）：
对于（int i=0；i<10；i++）{
//做事
a[i]=INT；
}
O（n）：
对于（int i=0；i

• O（log（n））可以描述什么代码

另一个问题：

• “大O问题”有什么解决方案（当获取大量数据作为输入时，该怎么办）
经典示例：

while (x > 0) {  
   x /= 2;  
}  

这将是：

Iteration |   x
----------+-------
    0     |   x
    1     |  x/2
    2     |  x/4
   ...    |  ...
   ...    |  ...
    k     |  x/2^k 

2k=x→ 将日志应用于两侧→ k=log（x）
对于O（logn），请查看任何涉及分而治之策略的代码

---

示例：合并排序和快速排序（在这些情况下，预期运行时间为O（nlogn）
二进制搜索就是一个示例O（log（n））
根据定义，log（n）（我这里指的是以2为基数的log，但基数真的不重要），是2自身乘以n的次数。因此，O（log（n））代码示例为：

i = 1
while(i < n)
    i = i * 2
    // maybe doing addition O(1) code

i=1
而（i

---

在实际代码示例中，您可以在二进制搜索、平衡二进制搜索树、许多复活算法、优先级队列中遇到O（log（n））。
值得强调的是，您描述的低复杂度算法是高复杂度算法的子集。换句话说,

for (int i = 0; i < 10; i++) {
    // do stuff 
    a[i] = INT;
}

for（int i=0；i<10；i++）{
//做事
a[i]=INT；
}

在O（1）中，但也在O（n），O（n²）中，如果你想变得聪明，还有O（log（n））。为什么？因为所有的常数时间算法都有一些线性、二次等函数的限制
“大O问题”有什么解决方案（当获取大量数据作为输入时，该怎么办）

---

这个问题对我来说没有多大意义。“大量数据”是一个相当武断的说法。不过，请记住，大O并不是衡量时间复杂性的唯一标准；除了测量最坏情况的时间复杂度外，我们还可以检查最佳情况和平均情况，尽管计算起来有点困难
在二进制搜索的情况下，您试图找到最大的迭代次数，因此搜索空间可以分成两半的最大次数。这是通过重复将搜索空间的大小n除以2来实现的，直到得到1
让我们给出将n除以2的次数。由于除以2，x倍等于除以2^x，因此必须求解此方程：
n/2^x=1，变为n=2^x
所以使用对数，x=log（n），所以二进制搜索的大-O是O（log（n））
重申：x是将大小为n的空间分成两半，然后缩小为大小为1的次数

---

最简单的代码，带有for循环，可用于表示：
O（1）：

function O_1(i) {
    // console.log(i);
    return 1
}

function O_N(n) {
    count = 0;
    for (i = 0; i < n; i++) {
        // console.log(i);
        count++;
    }
    return count
}

function O_N2(n) {
    count = 0;
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            // console.log(i, j);
            count++;
        }
    }
    return count
}

function O_LOG_2(n) {
    count = 0;
    for (var i = 1; i < n; i = i * 2) {

        count++;
    }
    return count
}

function O_SQRT(n) {
    count = 0;
    for (var i = 1; i * i < n; i++) {
        // console.log(i);
        count++;
    }
    return count
}

O（n）：

function O_1(i) {
    // console.log(i);
    return 1
}

function O_N(n) {
    count = 0;
    for (i = 0; i < n; i++) {
        // console.log(i);
        count++;
    }
    return count
}

function O_N2(n) {
    count = 0;
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            // console.log(i, j);
            count++;
        }
    }
    return count
}

function O_LOG_2(n) {
    count = 0;
    for (var i = 1; i < n; i = i * 2) {

        count++;
    }
    return count
}

function O_SQRT(n) {
    count = 0;
    for (var i = 1; i * i < n; i++) {
        // console.log(i);
        count++;
    }
    return count
}

函数O_N（N）{
计数=0；
对于（i=0；i

O（n²）：

function O_1(i) {
    // console.log(i);
    return 1
}

function O_N(n) {
    count = 0;
    for (i = 0; i < n; i++) {
        // console.log(i);
        count++;
    }
    return count
}

function O_N2(n) {
    count = 0;
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            // console.log(i, j);
            count++;
        }
    }
    return count
}

function O_LOG_2(n) {
    count = 0;
    for (var i = 1; i < n; i = i * 2) {

        count++;
    }
    return count
}

function O_SQRT(n) {
    count = 0;
    for (var i = 1; i * i < n; i++) {
        // console.log(i);
        count++;
    }
    return count
}

函数O_N2（n）{
计数=0；
对于（i=0；i

O（Log_2（n））：

function O_1(i) {
    // console.log(i);
    return 1
}

function O_N(n) {
    count = 0;
    for (i = 0; i < n; i++) {
        // console.log(i);
        count++;
    }
    return count
}

function O_N2(n) {
    count = 0;
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            // console.log(i, j);
            count++;
        }
    }
    return count
}

function O_LOG_2(n) {
    count = 0;
    for (var i = 1; i < n; i = i * 2) {

        count++;
    }
    return count
}

function O_SQRT(n) {
    count = 0;
    for (var i = 1; i * i < n; i++) {
        // console.log(i);
        count++;
    }
    return count
}

函数O_LOG_2（n）{
计数=0；
对于（变量i=1；i

O（Sqrt（n））：

function O_1(i) {
    // console.log(i);
    return 1
}

function O_N(n) {
    count = 0;
    for (i = 0; i < n; i++) {
        // console.log(i);
        count++;
    }
    return count
}

function O_N2(n) {
    count = 0;
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            // console.log(i, j);
            count++;
        }
    }
    return count
}

function O_LOG_2(n) {
    count = 0;
    for (var i = 1; i < n; i = i * 2) {

        count++;
    }
    return count
}

function O_SQRT(n) {
    count = 0;
    for (var i = 1; i * i < n; i++) {
        // console.log(i);
        count++;
    }
    return count
}

函数O_SQRT（n）{
计数=0；
对于（变量i=1；i*i

---

O（logn）通常是算法分而治之的时候，比如二进制搜索或类似的。下面是一个实用的（编码测试）示例=>请看问题和解决方案伟大而简单的示例，正是我要找的！thak you:）我错过了你得到2^k=x的那一刻，当时是x/2^k？1是最后一次迭代。所以我想知道在哪一点上，这将被评估为1。这是有史以来最好的解释。非常感谢。@DanielGurianov，x/2^k的除法最终将得到1。将这一点等同于，1=x/2^k，这相当于，x=2^k，这取决于应用日志。当b被提升到y的幂等于x:b^y=x；在这种情况下，2^y=x，那么x的底b对数等于y:logb（x）=y；在这种情况下，k=log（x），表示以log为基数2