C++における時間計算量

標準ライブラリのコンテナとアルゴリズムの時間計算量について解説する。本記事で“計算量”と記述した場合、特に注釈のない限りは時間計算量を指す。


## 基本的な計算量と、C++における代表例

ここで説明する内容は一般論なので、特殊な条件は考慮しない。

- 要素数に依存しない初期化： $O(1)$
- 要素数に依存した初期化: $O(n)$
- ソートを伴う初期化: $O(n \log n)$

| 計算量（少ない順） | 名称 | C++における代表例 |
|---|---|---|
| $O(1)$ | 定数時間<br>(*constant*) | デフォルトコンストラクタ<br>デフォルトデストラクタ<br>デストラクタ（子要素が無いもの）<br>ムーブコンストラクタ<br>`swap` 操作<br>生配列の添え字アクセス<br> *（時に規定がない場合の計算量とメモリ使用量として想定できるもの）* |
| （記号は特に無し） | 償却定数時間<br>(*amortized constant*) | [`std::vector::push_back`](https://cpprefjp.github.io/reference/vector/push_back.html) <br> *（たまに非常に長い時間がかかるが通常は短い時間で完了するために、平均的には定数時間と同等まで償却できるもの）* |
| $O(\log n)$ | 対数時間<br>(*logarithmic*) | 距離や範囲の再計算<br> *（前方向イテレータ要件を満たさないイテレータ範囲による初期化におけるメモリ再確保）* |
| $O(n)$ | 線形時間<br>(*linear*) | デストラクタ（全ての要素を破棄する必要があるもの）<br>コピーコンストラクタ<br>[`std::unordered_set` 同士の等値比較](https://cpprefjp.github.io/reference/unordered_set/unordered_set/op_equal.html) *（平均計算時間）* |
| $O(n \log n)$ | 線形対数時間<br>(*log-linear*) | [`std::sort`](https://cpprefjp.github.io/reference/algorithm/sort.html) <br> 一般的に **速い** とされるソート *（平均計算時間）* |
| $O({n^2})$ | 二乗時間<br>(*quadratic*) | 二重ループ<br>一般的に **遅い** とされるソート *（最悪計算時間）*<br>[`std::unordered_set` 同士の等値比較](https://cpprefjp.github.io/reference/unordered_set/unordered_set/op_equal.html) *（最悪計算時間）* |
| $O({n^c}), \exists c\ge 1$ | 多項式時間<br>(*polynomial*) | 多重ループ<br>行列計算 |
| $O({c^n}), \exists c\ge 1$ | 指数時間<br>(*exponential*) | ナイーブな素数探索と因数分解<br> *（遅すぎるため実用的でない）* |
| $O(n!)$ | 階乗時間<br>(*factorial*) | ナイーブな行列計算、巡回セールスマン問題の総当たり計算<br> *（遅すぎるため実用的でない）* |


## コンテナの計算量

本項ではセマンティクス全体の計算量を記載する。ただし内部実装による複数回の計算が明らかでかつ直感と反する場合は、これを併記する。

ここでは、以下に示すような通常の条件下での計算量を記載する。

- 処理系定義の最適化を考慮しない
- メモリ再確保が起こらない
- 要素自体はムーブ構築される

限定された条件下における厳密な計算量については、各メンバ関数のリファレンスを参照すること。

### 通常のセマンティクスと計算量

| 種類 | N要素の初期化 | コピー | 先頭 | 絶対位置 | 末尾 | 位置挿入 | 位置削除 |
|---|---|---|---|---|---|---|---|
| セマンティクス | <nobr>**`C c{first, last};`**</nobr> | <nobr>**`C c2{c1};`**</nobr><br><nobr>**`auto c2 = c1;`**</nobr> | <nobr>**`e = c.front();`**</nobr> | <nobr>**`e = c[i];`**</nobr><br><nobr>**`e = c.at(i);`**</nobr> | <nobr>**` e = c.back();`**</nobr> | <nobr>**`c.insert(pos, e);`**</nobr> | <nobr>**`c.erase(pos);`**</nobr> |
| **生配列**<br>[`array`](https://cpprefjp.github.io/reference/array.html) | $O(n)$ | $O(n)$ | $O(1)$ | $O(1)$ | $O(1)$ | - | - |
| [`vector`](https://cpprefjp.github.io/reference/vector.html) | $O(n)$ | $O(n)$ | $O(1)$ | $O(1)$ | $O(1)$ | $O(n)$<br>*（※数と位置に応じて）* | $O(n)$<br>*(※破棄 $n$)* |
| [`deque`](https://cpprefjp.github.io/reference/deque.html) | $O(n)$ | $O(n)$ | $O(1)$ | $O(1)$ | $O(1)$ | $O(n)$<br>*（※構築 $n$ + 伸長 $n$）* | $O(n)$<br>*（※破棄 $n$ + 収縮 $n$）*  |
| [`list`](https://cpprefjp.github.io/reference/list.html) | $O(n)$ | $O(n)$ | $O(1)$ | - | $O(1)$| $O(1)$ | $O(1)$<br>*(※破棄 $n$）* |
| [`forward_list`](https://cpprefjp.github.io/reference/forward_list.html) | $O(n)$ | $O(n)$ | $O(1)$ | - | - | $O(1)$ | $O(1)$<br>*(※破棄 $n$）* |
| [`set`](https://cpprefjp.github.io/reference/set.html) | *ソート済：* $O(n)$<br> *未ソート：* $O(n \log n)$ | $O(n)$ | - | - | - | **ヒント付** | **ヒント付** |
| [`unordered_set`](https://cpprefjp.github.io/reference/unordered_set.html) | *平均：* $O(n)$ <br> *最悪：* $O(n^2)$ | *平均：* $O(n)$ <br> *最悪：* $O(n^2)$ | - | - | - | **ヒント付** | **ヒント付** |
| [`map`](https://cpprefjp.github.io/reference/map.html) | *ソート済：* $O(n)$<br> *未ソート：* $O(n \log n)$ | $O(n)$ | - | $O(\log n)$ | - | **ヒント付** | **ヒント付** |
| [`unordered_map`](https://cpprefjp.github.io/reference/unordered_map.html) | *平均：* $O(n)$ <br> *最悪：* $O(n^2)$ | *平均：* $O(n)$ <br> *最悪：* $O(n^2)$ | - | *平均:* $O(1)$<br>*最悪:* **$O(n)$** | - | **ヒント付** | **ヒント付** |



### 特別なセマンティクスと計算量

| 種類 | 検索 | 一致範囲 | 指定挿入 | 指定削除 |
|---|---|---|---|---|
| セマンティクス | <nobr>**`it = c.find(k);`**</nobr> | <nobr>**`b = c.equal_range(k);`**</nobr> | <nobr>**`c.insert(e);`**</nobr><br><nobr>**`c.insert({k, v});`**</nobr> | <nobr>**`c.erase(k);`**</nobr> |
| 連想コンテナ | <nobr>$O(\log n)$</nobr> | <nobr>$O(\log n)$</nobr>  | <nobr>$O(\log n)$</nobr> | $O(\log n), n = size()$ |
| ハッシュセット | *平均：* $O(1)$ <br> *最悪：* **$O(n)$**  | <nobr>*平均：* $O(n), n = count(k)$</nobr><br>*最悪：* $O(n), n = size()$ | *平均：* $O(1)$ <br> *最悪：* **$O(n)$** | <nobr>*平均：* $O(n), n = count(k)$</nobr><br>*最悪：* $O(n), n = size()$ |
| ハッシュマップ | （同上） | *平均：* $O(1)$ <br> *最悪：* **$O(n)$** | （同上） | （同上） |
| その他のコンテナ | - | - | - | - |


### 凡例

- **`C`**  
  コンテナのクラス
- **`c`**, **`c1`**, **`c2`**  
  *`C`* クラスのオブジェクト
- **`e`**  
  要素（通常は *`C::value_type`*）
- **`first`**, **`last`**  
  `InputIterator` コンセプトを満たす [*first*, *last*) 範囲のイテレータ
- **`it`**  
  検索結果の要素の位置を示すイテレータ（通常は *`C::const_iterator`*）
- **`b`**  
  下境界と上境界のペア（通常は *`std::pair<C::const_iterator, C::const_iterator>`*）
- **`pos`**  
  挿入位置を示すイテレータ（通常は *`C::const_iterator`*）
- **`k`**  
  連想コンテナにおけるキー（通常は *`C::key_type const&`* ）
- **`i`**  
  添え字（通常は *`std::size_t`*）
- $count(k)$  
  操作の対象となった要素数
- $size()$  
  コンテナの全要素数
- *連想コンテナ*  
  C++に古くからあるコンテナ。  
  重複要素を許容するものと許容しないものがあり、格納順が規定されている。  
   [`set`](https://cpprefjp.github.io/reference/set/set.html) 、 [`multiset`](https://cpprefjp.github.io/reference/set/multiset.html) 、 [`map`](https://cpprefjp.github.io/reference/map/map.html) 、 [`multimap`](https://cpprefjp.github.io/reference/map/multimap.html)
- *ハッシュコンテナ、ハッシュセット、ハッシュマップ*  
  C++11から入った、内部実装にハッシュテーブルを用いるコンテナ。  
  重複要素は許容されず、格納順も規定されない。  
   [`unordered_set`](https://cpprefjp.github.io/reference/unordered_set.html) 、 [`unordered_map`](https://cpprefjp.github.io/reference/unordered_map.html)
- **「-」** （半角ハイフン）  
  そのセマンティクスが対象のコンテナに存在しないことを示す。
- **「ヒント付」**  
  限定された条件下の操作でヒントを正しく指定すると、計算量は大幅に減る。  
  詳細については、各メンバ関数のリファレンスを参照すること。


### 備考

- $O(size())$ と $O(N)$ はどちらも $O(n)$ である。ここで、 $size()$ はコンテナ自身の要素数、 $N$ は操作の対象となった要素数。
- あるセマンティクスの全体の計算量が **線形時間** でも、内部実装では **線形時間未満の複数の操作** が行われることがある。
- 操作対象の要素数 $N$ より全要素数 $size()$ の方が、結果的にプログラムの実行時間に与える影響が大きいことがある。
- 先頭または末尾への１要素の挿入／削除が特別にサポートされているコンテナでは、その操作の計算量は基本的に **定数時間** である。  
  （例： [`std::deque::push_front`](https://cpprefjp.github.io/reference/deque/push_front.html) 、 [`std::deque::pop_back`](https://cpprefjp.github.io/reference/deque/pop_back.html) ）
- 前項の例外として、 [`std::vector::push_back`](https://cpprefjp.github.io/reference/vector/push_back.html) の計算量は、 **定数時間ではなく** 、 **償却定数時間** である。
-  [`std::array`](https://cpprefjp.github.io/reference/stack.html) 以外のコンテナにおける `swap` 操作の計算量は、 **定数時間** である。
-  [`std::stack`](https://cpprefjp.github.io/reference/stack.html) 、 [`std::queue`](https://cpprefjp.github.io/reference/queue/queue.html) 、 [`std::priority_queue`](https://cpprefjp.github.io/reference/queue/priority_queue.html) 等のコンテナアダプタの計算量は、内部実装の計算量に準じる。
-  重複要素を許容する連想コンテナの計算量は、重複要素を許容しない連想コンテナの計算量に準じる。
-  [`std::forward_list`](https://cpprefjp.github.io/reference/forward_list.html) はゼロオーバーヘッドを重視した設計のため、コンテナの要素数を **定数時間** で取得することはできない（他のコンテナは通常は定数時間として規格に規定されている）。
- [`std::valarray`](https://cpprefjp.github.io/reference/valarray.html) は専ら数値演算を目的として処理系定義の最適化が行われる可能性が高く、厳密な計算量の定義が難しいため、本記事では解説しない。



## 参考：セマンティクスについて

この記事では、C++が標準規格でサポートしている **セマンティクス** における計算量を解説した。

セマンティクスとは、プログラムの **意味** を指す用語である。対応する概念として、「シンタックス  **（構文）** 」がある。ある操作がC++標準規格上の関数として用意されているとき、シンタックスと同時にそのセマンティクスがサポートされているといえる。

重要なことだが、 **複数のシンタックスの組み合わせを使って問題を解決することができても、そのプログラミング言語でそのセマンティクスがサポートされていない場合はしばしば非効率になる。** ましてやC++はローレイヤーな書き方も可能な言語なので、やろうと思えば何でも出来てしまう。しかし、そのようなローレイヤーな構文の組み合わせで問題を解決することができても、効率的なプログラムにはならない。

効率的な書き方が出来ない場合は、そのプログラムが対象とする問題が計算複雑性理論上既知な難題として知られているはずである（※P≠NP予想などによる）。効率的に解決できないとして知られている有名な問題には、素数判定や巡回セールスマン問題などがある。これらの厳密解は **多項式時間** 以下で解くことができないが、近似解で妥協することや問題設定を見直して簡単にすることで多項式時間で解く現実的な手法が色々な人によって研究されている（詳細は割愛）。

C++が言語としてサポートしていない操作を行おうとしたとき非効率になる例として、 **「コンテナの絶対位置の要素を取得するプログラム」** を書く例を以下に示す：

### `std::vector` の場合

この操作は `std::vector` では生配列と同じように、 **定数時間** で終わることが規定されている。

```cpp
std::vector<int> v;
auto const e = v[42]; // 42番目の絶対位置の要素を取得
```

`std::advance()` を使って同じく **定数時間** で書くこともできる。

```cpp
std::vector<int> v;
auto it = v.cbegin();
std::advance(it, 42); // `v[42]` と同等になることが規格で保証されているので、定数時間になる
auto const e = *it;
```

全く同じことを `for` ループで書くこともできる：
（※このコードは悪い書き方の例なので、このような書き方をしてはいけない。これは **定数時間にはならない**）

```cpp
auto it = v.cbegin();
for (int i = 0; i < 42; ++i) {
  ++it;
}

auto const e = *it;
```

### `std::list` の場合

`std::list` では `v[i]` のセマンティクスはサポートされていない（連結リストなので当然である）。そのかわり、 `std::advance()` を使って先頭から `i` まで辿ることで同じプログラムを書ける。

```cpp
std::list<int> l;
auto it = l.cbegin();
std::advance(it, 42); // 42回インクリメントするのと同じ。定数時間にはならない！
auto const e = *it;
```

これはvectorの例のように `for` 文で書くのと同じである。これはサポートされていないので、非効率になる。