Question

我已经实现了一个代码来构建模式计数树。我如何找到时间和空间的复杂性？

class PCTree
{
public static void main(String args[])throws IOException
{
 BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
 int n;//No of Patterns
 int f;//No of Features
 float initial_no_of_nodes=0;//No of Nodes in Input Patterns
 float final_no_of_nodes=0;//No of Nodes in PC Tree(Output)
 float compression_rate;//percentage compression

 System.out.println("Enter No of Patterns:");
 n=Integer.parseInt(input.readLine());

 //2-D array to store Features
 int pattern[][]= new int[n][20];

//No of Features for each Pattern
 for(int i=0;i<n;i++)//NO of Features for each Pattern
 { 
     System.out.println("Enter No of Features for Pattern "+(i+1)+" : ");
     f=Integer.parseInt(input.readLine());
     pattern[i]=new int[f];
 }

//Features of each pattern
for(int i=0;i<n;i++)
 {
    System.out.println("Enter Features for Pattern "+(i+1)+" : ");
    for(int j=0;j<pattern[i].length;j++)
    {
    pattern[i][j]=Integer.parseInt(input.readLine());
    }
 }


 System.out.println("==============");
 System.out.println("INPUT ");
 System.out.println("==============");

//Print Features of each pattern
for(int i=0;i<n;i++)
 {

    for(int j=0;j<pattern[i].length;j++)
    {
    System.out.print(" "+pattern[i][j]+" ");
    initial_no_of_nodes++;
    }
    System.out.println();
 }
 System.out.println("\nNODES: "+initial_no_of_nodes);//Print Initial No of Nodes
 System.out.println();
 System.out.println();
 System.out.println("==============");
 System.out.println("PC TREE ");
 System.out.println("==============");

 //Construction of PC Tree
 //Print First Pattern as it is
 for(int j=0;j<pattern[0].length;j++)
    {
    System.out.print(" "+pattern[0][j]+" ");
    final_no_of_nodes++;
    }
    System.out.println();

    int i=0;//processing pattern
    int k=0;//processing features
    int j=1;//processing pattern


while((i<=(n-1))&&(j<n))//Loop works till last pattern is processed  
{   
   inner: //performs matching of Features
   while(k<pattern[j].length)
    {
    if (pattern[i][k]==pattern[j][k])//Equal Prefix Found
        {
        System.out.print(" _ ");//Print "Blank" Indicate sharing
        k++;
        }
    else//Prefix not equal
     {

        for(int p=k;p<pattern[j].length;p++)//print all features(suffix) 
        {
        System.out.print(" "+pattern[j][p]+" ");
        final_no_of_nodes++;
        }
        i++;//next pattern
        j++;//next pattern
        k=0;//start again from first feature
        break inner;//go to next pattern
     }
    }
    System.out.println();

}   
 System.out.println("\nNODES: "+final_no_of_nodes);
 compression_rate=((initial_no_of_nodes-final_no_of_nodes)/initial_no_of_nodes)*100;
 System.out.println();  
 System.out.println("COMPRESSION RATE: "+compression_rate);  
}

}

我如何找到时间和空间的复杂性？

Answer 1

时间复杂度如下

每次初始化的O（1）
每个循环的O（n）
每个嵌套循环的O（n ^ 2）
O（n ^ 3）表示嵌套循环中的if条件

对于这部分代码

 BufferedReader input=new BufferedReader(new InputStreamReader(System.in));
 int n;//No of Patterns
 int f;//No of Features
 float initial_no_of_nodes=0;//No of Nodes in Input Patterns
 float final_no_of_nodes=0;//No of Nodes in PC Tree(Output)
 float compression_rate;//percentage compression

 System.out.println("Enter No of Patterns:");
 n=Integer.parseInt(input.readLine());

 //2-D array to store Features
 int pattern[][]= new int[n][20];

复杂性只是初始化时的语句编号

for(int i=0;i<n;i++)
 {
    System.out.println("Enter Features for Pattern "+(i+1)+" : ");
    for(int j=0;j<pattern[i].length;j++)
 {
    pattern[i][j]=Integer.parseInt(input.readLine());
    }
  }

复杂性将是O（n ^ 2）

for(int j=0;j<pattern[0].length;j++)
    {
    System.out.print(" "+pattern[0][j]+" ");
    final_no_of_nodes++;
    }

复杂性将是O（n）

while((i<=(n-1))&&(j<n))//Loop works till last pattern is processed  
{   
   inner: //performs matching of Features
   while(k<pattern[j].length)
    {
    if (pattern[i][k]==pattern[j][k])//Equal Prefix Found
        {
        System.out.print(" _ ");//Print "Blank" Indicate sharing
        k++;
        }

复杂性将是O（n ^ 3）

并且除了这些之外的语句的复杂性将具有复杂性O（1）每个

因此复杂性将为n + n ^ 2 + n ^ 3

所以使用条件n ^ 3＆gt;＆gt; n和n ^ 3＆gt;＆gt; n ^ 2复杂度将 O（n ^ 3）

可以使用

Type        Typical Bit Width   
char            1byte       
unsigned char   1byte        
signed char     1byte       
int             4bytes      
unsigned int    4bytes  
signed int      4bytes  
short int       2bytes  
long int        4bytes

Answer 2

构造while((i<=(n-1))&&(j<n))定义了两个嵌套循环。每次迭代最多n次，因此它们取O（n ^ 2）* T'（n），其中T'（n）是由while(k<pattern[j].length)语句定义的最内循环所花费的时间。

最内层循环最多执行pattern[j].length次，并且必须使用不同的分支，一个占用恒定时间，另一个嵌套循环最多执行pattern[j].length。这意味着内循环所花费的时间最多为20 * 20 = 400，即T'（n）= O（400）= O（1），因为它是一个常数，我认为，它不依赖于输入的大小n。

因此整个算法的渐近复杂度为O（n ^ 2）。

但是，看看你的代码，这看起来很可疑：

int pattern[][]= new int[n][20];

for(int i=0;i<n;i++){ 
  System.out.println("Enter No of Features for Pattern "+(i+1)+" : ");
  f=Integer.parseInt(input.readLine());
  pattern[i]=new int[f];
}

首先将每个数组pattern[i]定义为大小为20，然后允许用户重新定义它。这意味着它可能大于20并且我的分析不起作用。实际上，如果用户输入的最大特征数为m，则渐近时间为O（m * n ^ 2）。现在，如果m = O（1）（一个小常数），则该公式减少到前一个。但是，如果m = O（n）（与模式数量成比例），则复杂性变为立方，如另一个答案中所述。

Answer 3

有关时间复杂度的更正式说明，请参阅http://en.wikipedia.org/wiki/Time_complexity。基本上，您需要计算基本操作的数量。在这种情况下，您只需要计算循环中的迭代次数。

您的第一个for循环有n次迭代（O(n)）。你的第二个和第三个循环有n*20次迭代（外部循环n，内部循环20），给出O(2*(n*20)) = O(n)。第四个循环是20次迭代，它只是O(1)。最糟糕的情况是，最后一个循环有n*39次迭代，再次给出O(n)。所以你的时间复杂度是

 O(n) + O(n) + O(1) + O(n) = O(n)

计算空间复杂度有点棘手。这取决于范围。您基本上只计算每个变量的大小，但您需要知道BufferedReader对象的大小。

如何找到此代码的时间和空间复杂度？

3 个答案: