1. 基本的な考え方

データ構造: 相互に 1 つ以上の特定の関係を持つデータ要素のコレクション。論理的には、線形構造、ハッシュ構造、ツリー構造、グラフ構造などに分けることができます。

アルゴリズム: 特定の問題を解決するための手順の説明。コードは、特定の問題を解決するための限定された命令シーケンスのセットとして表現されます。

アルゴリズムの複雑さ: 時間と空間の複雑さ。アルゴリズムの効率を測定します。アルゴリズムの実行中、データサイズ n が増加するにつれて、アルゴリズムの実行に費やされる時間と空間が増加します。

一般的な時間計算量:

表現	ビッグオー表記	方程式
5201314	○(1)	一定の順序
3n+4	の上）	線形秩序
3n^2+4n+5	O(n^2)	平方オーダー
3log(2)n+4	O(ログン)	対数次数
2n+3nlog(2)n+14	O(nlogn)	nログン注文
n^3+2n^2+4n+6	O(n^3)	立方次数
2^n	O(2^n)	指数関数的順序

一般的なアルゴリズムの時間計算量の関係: O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(2^n) < O(n!) < O( n ^n)

【複雑さの指標の比較】

【作成したデータ構造のアルゴリズムの複雑さ】

ビッグオープラン	応用例
○(1)	配列ランダムアクセス、ハッシュテーブル
O(ログン)	バイナリサーチ、バイナリヒープ調整、AVL、赤黒ツリーサーチ
の上）	線形探索
O(nlogn)	ヒープソート、クイックソート、マージソート
O(n^2)	バブルソート、選択ソート、挿入ソート
O(2^n)	サブセットツリー
の上！）	アレンジメントツリー

2. 時間計算量

【2.1】時間計算量の概念

時間計算量の定義: コンピューターサイエンスでは、アルゴリズムの時間計算量は、アルゴリズムの実行時間を定量的に記述する関数です。アルゴリズムの実行にかかる時間は理論的に計算することはできず、プログラムをマシンに入れて実行する場合にのみ知ることができます。しかし、コンピューター上ですべてのアルゴリズムをテストする必要があるでしょうか?

全てをコンピュータ上でテストすることも可能ですが、非常に面倒なので、時間計算量解析手法を導入します。アルゴリズムにかかる時間は、そのステートメントの実行回数に比例し、アルゴリズム内の基本演算の実行回数がアルゴリズムの時間計算量となります。

つまり、特定の基本ステートメントと問題サイズ N の間の数式を見つけることは、アルゴリズムの時間計算量を計算することになります。

// 请计算一下Func1中++count语句总共执行了多少次？
void Func1(int N)
{
	int count = 0;
	for (int i = 0; i < N; ++i) // 循环次数为N^2
	{
		for (int j = 0; j < N; ++j)
		{
			++count;
		}
	}

	for (int i = 0; i < 2 * N; i++) // 循环次数为2 * N
	{
		++count;
	}

	int M = 10;
	while (M--) // 循环次数为10
	{
		++count;
	}

	printf("%d\n", count);
}
// Func1 执行的基本操作次数 ：F(N) = (N^2) + (2 * N) + 10
// 比如：N = 10		F(N) = 130
// 比如：N = 100		F(N) = 10210
// 比如：N = 1000	F(N) = 1002010
// 上面N越大后面两项对整个表达式的影响是越来越小的
// 实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。
// 最终以大概的次数：上面代码的时间复杂度是N^2

【2.2】ビッグオーの漸近表現

Big O 記法: 関数の漸近的な動作を記述するために使用される数学的記法です。

【ビッグオーオーダー法の導出】

実行時間内のすべての加算定数を定数1に置き換えます。O1 は 1 回を意味するのではなく、一定の時間を意味します。
変更された実行数関数では、最上位の項のみが保持されます。
最上位の項が存在し、それが 1 でない場合は、この項に乗じた定数を削除します。結果はビッグオーオーダー。

[Big O の漸近表現を使用した後、Func1 をプッシュする時間計算量は次のようになります]

// Func1 执行的基本操作次数 ：F(N) = (N^2) + (2 * N) + 10
// 比如：N = 10		F(N) = 130
// 比如：N = 100		F(N) = 10210
// 比如：N = 1000		F(N) = 1002010
// 结果：去掉(2*N)去掉(10) -> 时间复杂度是N^2

以上より、Big O の漸近表現は、結果に影響の少ない項目を削除し、実行回数を簡潔かつ明確に表現していること、また、アルゴリズムによっては時間計算量が最良、平均、最悪であることがわかります。ケース:

最悪の場合: 任意の入力サイズに対する実行の最大数 (上限)。
平均ケース: 任意の入力サイズに対する予想される実行数。
最良の場合: 任意の入力サイズに対する最小実行数 (下限)。
例: 長さ N の配列でデータ x を検索します。
最良のケース: 1 回見つかりました。
最悪の場合: N 回見つかりました。
平均的な状況: N/2 回見つかりました。

実際には、一般的に懸念されるのは、アルゴリズムの最悪の場合の動作です。

【2.3】時間計算量の計算例

【例】

// 计算Func2的时间复杂度？
void Func2(int N)
{
	int count = 0;
	for (int k = 0; k < 2 * N; ++k)// 循环次数：2 * N
	{
		++count;
	}

	int M = 10;
	while (M--) // // 循环次数：10
	{
		++count;
	}
	printf("%d\n", count);
}
// 正常为：(2 * N) + 10 
// 在此：10 影响不大， 2为固定值影响不大，影响时间复杂度的是N
// 以大O表示法：O(N)

【例】

// 计算Func3的时间复杂度？
void Func3(int N, int M)
{
	int count = 0;
	for (int k = 0; k < M; ++k) // 循环次数为：M次
	{
		++count;
	}
	for (int k = 0; k < N; ++k) // 循环次数为：N次
	{
		++count;
	}
	printf("%d\n", count);
}
// 正常为：M + N
// 在此：M 和 N 的准确值都是不知道的，所以都算在时间复杂度成员里
// 以大O表示法：O(M + N)

【例】

// 计算Func4的时间复杂度？
void Func4(int N)
{
	int count = 0;
	for (int k = 0; k < 100; ++k) // 循环次数为：100次
	{
		++count;
	}
	printf("%d\n", count);
}
// 正常为：100次
// 在此：N 没有参与任何东西
// 以大O表示法：O(1)

【例】

// 计算strchr的时间复杂度？
const char * strchr(const char * str, int character); // O(N)

【例】

// 计算BubbleSort的时间复杂度？
void BubbleSort(int* a, int n)
{
	assert(a);
	for (size_t end = n; end > 0; --end) // 循环次数为：等差数列
	{									 // N-1 N-2 N-3 N-4.... -> 1+2+3+N-1 = N(N-1)/2
		int exchange = 0;
		for (size_t i = 1; i < end; ++i)  
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				exchange = 1;
			}
		}
		if (exchange == 0)
			break;
	}
}
// 正常为：
// 在此：实例5基本操作执行最好N次，最坏执行了(N*(N+1)/2次，通过推导大O阶方法+时间复杂度一般看最坏，时间复杂度为 O(N ^ 2)
// 以大O表示法：O(N^2)这是最坏的情况加
// 最好的情况下是O(N)

【例】

// 计算BinarySearch的时间复杂度？
int BinarySearch(int* a, int n, int x) // O(N * Log(2)n)
{
	assert(a);

	int begin = 0;
	int end = n - 1;
	while (begin <= end)
	{
		int mid = begin + ((end - begin) >> 1);
		if (a[mid] < x)
			begin = mid + 1;
		else if (a[mid] > x)
			end = mid - 1;
		else
			return mid;
	}
	return -1;
}

【例】

// 计算阶乘递归Fac的时间复杂度？
long long Fac(size_t N) // O(N)
{
	if (0 == N)
		return 1;
	return Fac(N - 1)*N;
}

【例】

// 计算斐波那契递归Fib的时间复杂度？
long long Fib(size_t N) // O(2^N) -> 斐波那契数相当于是一个很垃圾的算法
{
	if (N < 3)
		return 1;
	return Fib(N - 1) + Fib(N - 2);
} 

// 优化
long long Fac(size_t N) 
{
	if (N < 3)
		return 1;

	long long f1 = 1, f2 = 1, f3;
	for (size_t i = 3; i <= N; i++)
	{
		f3 = f1 + f2;
		// 迭代
		f1 = f2;
		f2 = f3;
	}

	return f3;
}

3. 空間の複雑さ

スペース複雑度も数式であり、アルゴリズムが動作中に一時的に占有するストレージスペースの量の尺度です。

スペース複雑度は、プログラムが占めるスペースのバイト数ではありません。これはあまり意味がないため、スペース複雑度は変数の数によって計算されます。空間計算量の計算規則は基本的に実際の計算量と同様であり、ビッグ O の漸近表記も使用されます。

注:関数の実行時に必要なスタックスペース (パラメーター、ローカル変数、一部のレジスタ情報などの保存) はコンパイル中に決定されるため、スペースの複雑さは主に、実行時に関数によって明示的に適用される追加スペースによって決まります。。

【例】

// 计算BubbleSort的空间复杂度？
void BubbleSort(int* a, int n) // 常数个额外空间，所以空间复杂度为 O(1)
{
	assert(a);
	for (size_t end = n; end > 0; --end)
	{
		int exchange = 0;
		for (size_t i = 1; i < end; ++i)
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				exchange = 1;
			}
		}
		if (exchange == 0)
			break;
	}
}

【例】

// 计算Fibonacci的空间复杂度？
// 返回斐波那契数列的前n项
long long* Fibonacci(size_t n) // 动态开辟了N个空间，空间复杂度为 O(N)
{
	if (n == 0)
	{
		return NULL;
	}
		
	long long * fibArray = (long long *)malloc((n + 1) * sizeof(long long));

	fibArray[0] = 0;
	fibArray[1] = 1;
	for (int i = 2; i <= n; ++i)
	{
		fibArray[i] = fibArray[i - 1] + fibArray[i - 2];
	}
	return fibArray;
}

【例】

// 计算阶乘递归Fac的空间复杂度？
long long Fac(size_t N) // 递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)
{
	if (N == 0)
		return 1;
	return Fac(N - 1) * N;
}

[C データ構造] データ構造とアルゴリズムの複雑さの概要

1. 基本的な考え方

2. 時間計算量

【2.1】時間計算量の概念

【2.2】ビッグオーの漸近表現

【2.3】時間計算量の計算例

3. 空間の複雑さ

おすすめ