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

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

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);  
}

类PCTree { 公共静态void main（字符串args[]）引发IOException { BufferedReader输入=新的BufferedReader（新的InputStreamReader（System.in））； int n；//模式数 int f；//功能的数量 float initial_no_of_nodes=0；//输入模式中的节点数 float final_no_of_nodes=0；//PC树中的节点数（输出） 浮点压缩率；//压缩百分比 System.out.println（“输入模式编号：”）； n=Integer.parseInt（input.readLine（））； //用于存储要素的二维阵列 整数模式[][]=新整数[n][20]； //每个图案的特征数量

---

对于（int i=0；i而言，时间复杂度如下

O（1）对于每次初始化

每个回路的O（n）

O（n^2）对于每个嵌套循环

嵌套循环中if条件的O（n^3）

对于这部分代码

 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());
    }
  }

构造

while（（i）是关于时间复杂性的更正式的描述。基本上，您需要计算基本操作的数量。在这种情况下，您只需要计算循环中的迭代次数

你的第一个
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
对象的大小。
我认为if语句所用的时间与输入大小（n）不成正比.事实上，k的值可以从0到19，而不是从0到n。因此，在最内层循环（通过if间接定义）中花费的时间最多为20，即从渐近复杂性的角度来看为O（1）。因此复杂性为O（n^2）。是否有此sagar的参考？
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++;
        }

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  

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];
}

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