データ構造 - 時間計算/スペースの複雑さ

データ構造 - 時間計算/スペースの複雑さ

A）、複雑さ：

複雑さ：また、プログレッシブ複雑として知られています。

カテゴリー：1）時間複雑。

2）空間的複雑。

時間計算量： T（N）= O（F（N））、コードの実装は実行時間とコードに比例した回数。

T（N）：実行時間コード。

F（N）：コード実行の数。

N：データのサイズ。

O：トレンド実行時間とデータの増加のコードサイズ。

B）時間複雑分析：

1）、ショートコードまでのサイクル数に関係のみ

T（N）= O（N）

 int cal(int n) {
   int sum = 0;
   int i = 1;
   for (; i <= n; ++i) {
     sum = sum + i;
   }
   return sum;
 }

2）、さらにルール、T（N）= O（MAX（F（N）、G（N）））

シーン：複数のサイクル： T（N）= O（MAC（F（N）+ G（N ^ 2）））= O（^ N-2）

int cal(int n) {
   int sum_1 = 0;
   int p = 1;
   for (; p < 100; ++p) {
     sum_1 = sum_1 + p;
   }

   int sum_2 = 0;
   int q = 1;
   for (; q < n; ++q) {
     sum_2 = sum_2 + q;
   }
 
   int sum_3 = 0;
   int i = 1;
   int j = 1;
   for (; i <= n; ++i) {
     j = 1; 
     for (; j <= n; ++j) {
       sum_3 = sum_3 +  i * j;
     }
   }
 
   return sum_1 + sum_2 + sum_3;
 }

3）、乗算ルール、O（F（N））* O（G（N））= O（F（N）* G（N））

シーン：ネストされたループ： T（N）= O（F（N）* G（N））

T（N）= O（F（N）* G（N ^ 2））= O（F（N * N ^ 2））= O（F（N ^ 3））

int cal(int n) {
   int ret = 0; 
   int i = 1;
   for (; i < n; ++i) {
     ret = ret + f(i);
   } 
 } 
 
 int f(int n) {
  int sum = 0;
  int i = 1;
  for (; i < n; ++i) {
    sum = sum + i;
  } 
  return sum;
 }

スリー）、共通の時間複雑さの例

（1）<O（LOGN）<（N）<（nlogn）<O（N ^ 2）<O（N ^ 3）<O（2 ^ N）

（1）：

限りがループ、再帰的なアルゴリズムとして、コードの行数千があるにもかかわらず、時間の複雑さはO（1）です。

O（LOGN）：等比数列。

2 ^ 0 ^ 2 1 2 ^ 3 ^ X = N ..... 2、X = LOGN

O（nlogn）：

ループネストされたループとLOGN

2つのコードの複雑さは、データのサイズによって決定されるD）

O（M + M）= O（F（M））+ O（G（N））

O（M 、N）= O（F（M）） O（G（N））

宇宙複雑

多くの場合、一般的にO（n）とO（N ^ 2）遭遇した時の複雑さ