Question

我仍然无法分析O（logn）算法

因此，如果有嵌套的for循环，其内循环通过乘法或除法中的任何一个增加/减少，那么它是Big-theta（logn），其中它的基数是除以或乘以？

例如：

for(int i=n;i>0;i--) {
for(int j=i; j>0; j/=10) ...

this is 
Big-theta(logn) with base 10 since it is divided by 10?

另一个例子：

import socket
import sys


#create a tcp/ip socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

#print(socket.gethostbyname(socket.gethostname()))

#bind the socket to the port
server_address = (socket.gethostbyname(socket.gethostname()), 8000)
print('starting up on {} port {}'.format(*server_address))
sock.bind((socket.gethostname(),8000))

#listen for incoming connections
sock.listen(2)

while True:
    #wait for connection
    print('waiting for a connection')
    connection, client_address = sock.accept()
    try:
        print('connection from', client_address)

        host_name=socket.gethostname()
        h=("connected to: "+host_name).encode()
        connection.sendall(h)
        while True:
            print("enter a message")
            m=input().encode()
            connection.sendall(m)

    finally:
        #end the communication
        connection.close()

我的意思是，我能正确理解吗？

另一个问题：

Big-theta（logn）仅适用于嵌套循环？（for循环中的循环）

Answer 1

如果我们可以计算特定for循环的执行次数，那么我们可以轻松了解复杂性。我们可以从一个简单的for循环的例子开始。

考虑以下for循环，

for(int i=1;i<=m;i++)
{
    //....
}

现在，如果我们想要找到这个for循环运行多少次，那么我们可以通过编写系列（因为它是统一系列）来完成它，并找到哪个术语是> m(limit)。这样我们就可以轻松找到for循环所需的迭代次数。

在这个例子中，如果我们写出i的所有可能值，

1,2,3,4,5,......,m

这个系列是Arithmetic Progression。现在我们有一个等式来查找n-th系列的术语{a(n) = a(1)+(n-1)*d}。现在d=1, a(1)=1 a(n)<=m我们需要找到a(n)=m的最大值n。

我们可以通过简单地放置n并找到值m = 1+ (n-1)*1 m = 1+n-1 m = n n = m.来实现。所以这里

所以这里的总迭代次数为O(m)，因此我们可以说这个for循环的复杂性是for(int j=1; j<n; j*=5)...。

现在考虑一下你给出的一个例子，

如果你写下1,5,25,125,.....的所有值，那么系列就是n-th，现在这个系列是Geometric Progression。查找a(n) = a(1)*(r^(n-1))字词的公式为a(1)=1 and r=5，此处为n(limit)。

现在将a(n)替换为n以查看循环执行的次数，并让我们将限制m重命名为a(n) = a(1)*(r^(n-1)) m = 1*(5^(n-1)) m = 5^(n-1) Now take log of base 5 on both side log (m) = (n-1) //log is of base 5 n = log(m)+1以消除混淆，

n = log(m)+1

这样我们可以在这里找到所需的总迭代次数为O(log m)，其中log是基数5.删除常量后，我们可以说这个循环的复杂度为j，基数为5。

对于您提问的第二个示例，如果您编写n,n/10,n/100,....系列，您将获得Geometric Progression，因此它a(1)=n , r= 1/10也会a(n) 1将log n，因为我们需要找到该字词。如果您找到完整的迭代次数，则会将其作为基数为10的for(int i=1;i<=n;i*=2)。

Big-theta（logn）仅适用于嵌套循环？（for循环中的循环）

没有必要。假设我们只有一个循环具有以下格式，

O(log n)

此循环也具有const trimmerWithoutNaN = trimmer.filter(val => !isNaN(val))复杂度，并且它不是内循环。所以这取决于你的for循环的增量操作。它定义了for循环的整体复杂性。

O（logn）和算法的关系

1 个答案: