数据结构算法复杂度(1)

1.数据结构前言

1.1 数据结构

数据结构是计算机存储、组织数据的方式，它关注的是如何高效地管理和操作数据，以适应不同的

算法需求。简单来说，就是数据在计算机中的"排列组合"方式。可以把数据结构想象成日常生活中

"整理物品的方式"，不同的整理方式对应不同的数据结构，适用场景也不一样。

1.2 算法

算法(Algorithm):就是定义良好的计算过程，他取一个或一组值作为输入，并产生出一个获益组织

作为输出。简单来说，算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

1.3 算法和数据结构的关系

就像"做菜步骤"和"厨具食材"的关系：

数据结构是"食材和厨具"：比如数组、链表这些，是存放数据的"容器"，不同容器有不同特点（比

如数组像保鲜盒，取放快；链表像一串糖葫芦，方便增减）。

算法是"做菜步骤"：针对不同的食材（数据结构），步骤也会不一样。比如同样是"排序"（算法目

标），如果数据存在数组里，可能用"冒泡排序"更方便；如果存在链表上，可能用"插入排序"更合

适。

简单说**，数据结构是基础，算法是利用这些基础解决问题的方法**。好的算法需要搭配合适的数据结

构才能高效工作，就像做蛋糕得用烤箱（对应的数据结构），而不能用炒锅，否则步骤再对也做不

好

2.复杂度

复杂度可以理解为"做一件事的'费劲程度'"，主要用来衡量算法的效率 ，包括时间复杂度和空间复杂

度。

打个比方：

- 时间复杂度：比如你要从100张照片里找一张特定的。

笨办法是一张张翻（相当于"遍历"），运气差要翻100次，时间复杂度就高；

聪明办法是按日期分组，先找到大概日期的那堆，再从中找（相当于"二分查找"），可能10次就够

了，时间复杂度就低。

时间复杂度反映算法"跑得多快"。

- 空间复杂度：比如你整理房间时，要不要额外找箱子装东西。

直接在原地挪东西（比如某些排序算法），几乎不用额外空间，空间复杂度低；

必须找几个箱子临时放东西（比如某些复制、拆分操作），用的空间多，空间复杂度就高。

空间复杂度反映算法"占多少内存"。
复杂度和数据结构、算法的关系：

不同数据结构会影响算法的复杂度。比如用数组找数据，能直接定位位置（时间快）；用链表找，

就得一个个遍历（时间慢）。所以设计算法时，选对数据结构能降低复杂度，让程序更高效。

3.时间复杂度

定义:在计算机科学中，算法的时间复杂度是一个函数式T(N) ，它定量描述了该算法的运行时间。

时间间复杂度是衡量程序的时间效率时，那么为什么不去计算程序的运行时间呢?

因为程序运行时间和编译环境和运行机器的配置都有关系，比如同一个算法程序，用一个老编译

器进行编译和新编译器编译，在同样机器下运行时间不同。

同一个算法程序，用一个老低配置机器和新高配置机器，运行时间也不同。
并且时间只能程序写好后测试，不能写程序前通过理论思想计算评估。

那么算法的时间复杂度是一个函数式T(N)到底是什么呢? 这个T(N)函数式计算了程序的执行次数。

通过c语言编译链接章节学习，我们知道算法程序被编译后生成二进制指令，程序运行，就是cpu执

行这些编译好的指令。那么我们通过程序代码或者理论思想计算出程序的执行次数的函数式T(N)，

假设每句指令执行时间基本一样(实际中有差别，但是微乎其微)，那么执行次数和运行时间就是等

比正相关，这样也脱离了具体的编译运行环境。执行次数就可以代表程序时间效率的优劣。比如解

决一个问题的算法a程序T(N)=N，算法b程序T(N)=N^2，那么算法a的效率一定优于算法b。

案例:

cs 复制代码

//请计算一下Func1函数中++count语句总共只执行了多少次?
void Func1(int N)
{
	int count = 0;
	for (int i = 0;i < N;++i)
	{
		for (int j = 0;j < N;++j)
		{
			++count;
		}
	}

	for (int k = 0;k < 2 * N;++k)
	{
		++count;
	}
	int M = 10;
	while (M--)
	{
		++count;
	}
}

统计每个操作的执行次数

操作 1（嵌套循环内）：

外层循环 i 执行 N 次,内层循环 j 也执行 N 次,因此 ++count 执行次数是N * N = N^2次。

操作 2（单层循环）：

循环条件是 k < 2*N ,因此 ++count 执行 2 * N 次。

操作 3（固定次数循环）：

M 初始为 10,循环执行 10 次，因此 ++count 执行10次（与 N 无关，属于"常数项" ） 。

合并得到总执行次数公式

把所有操作次数相加，总执行次数 T(N) 为：

T(N) = N^2 + 2N + 10

N = 10 T(N)=130
N = 100 T(N)=10210
N = 1000 T(N)=1002010

通过对N取值分析，对结果影响最大的一项是N²

实际中我们计算时间复杂度时，计算的也不是程序的精确的执行次数，精确执行次数计算起来还是

很麻烦的(不同的一句程序代码，编译出的指令条数都是不一样的)，计算出精确的执行次数意义也

不大，因为我们计算时间复杂度只是想比较算法程序的增长量级，也就是当N不断变大时T(N)的差

别，上面我们已经看到了当N不断变大时常数和低阶项对结果的影响很小，所以我们只需要计算程

序能代表增长量级的大概执行次数，复杂度的表示通常使用大O的渐进表示法。

3.1 大O的渐进表示法

大O符号 (Big O notation) : 是用于描述函数渐进行为的数学符号

推导大O阶规则:

时间复杂度函数式T(N)中**，只保留最高阶项，去掉那些低阶项，因为当N不断变大时，低阶项对结果影响越来越小，当N无穷大时，就可以忽略不计了。**
如果最高阶项存在且不是1，则去除这个项目的常数系数，因为当N不断变大，这个系数对结果影响越来越小，当N无穷大时，就可以忽略不计了。

3.T(N)中如果没有N相关的项目，只有常数项，用常数1取代所有加法常数。

4.时间复杂度计算实例

4.1 实例1

cs 复制代码

//计算Fun2函数的时间复杂度?
void Func2(int N)
{
	int count = 0;
	for (int k = 0;k < 2 * N;++k)
	{
		++count;
	}
	int M = 10;
	while (M--)
	{
		++count;
	}
	printf("%d\n", count);
}

Func2执行的基本操作次数:

T(N) = 2N + 10

根据推导规则第2条得出:

Func2的时间复杂度为: O(N)

4.2 实例2

cs 复制代码

//计算Fun3函数的时间复杂度?
void Fun3(int N, int M)
{
	int count = 0;
	for (int k = 0;k < M;++k)
	{
		++count;
	}
	for (int k = 0;k < N;++k)
	{
		++count;
	}
	pritnf("%d\n", count);
}

Func3执行的基本操作次数:

T(N) = M + N

因此: Func3的时间复杂度为: O(N + M)

4.3 实例3

cs 复制代码

// 计算Func4的时间复杂度?
void Func4(int N)
{
    int count = 0;
    for (int k = 0; k < 100; ++ k)
    {
        ++count;
    }
    printf("%d\n", count);
}

Func4执行的基本操作次数:

T(N) = 100

根据推导规则第3条得出

Func4的时间复杂度为: O(1)

4.4 实例4

cs 复制代码

// 计算strchr的时间复杂度?
const char * strchr ( const char * str, int character)
{
    const char* p_begin = str;
    while (*p_begin != character)
    {
        if (*p_begin == '\0')
            return NULL;
        p_begin++;
    }
    return p_begin;
}

strchr执行的基本操作次数:

若要查找的字符在字符串第一个位置，则:

T(N) = 1

若要查找的字符在字符串最后的一个位置，则:

T(N) = N

若要查找的字符在字符串中间位置，则:

T(N) = N/2

因此: strchr的时间复杂度分为:

最好情况: O(1)
最坏情况: O(N)
平均情况: O(N)

通过上面我们会发现，有些算法的时间复杂度存在最好、平均和最坏情况。

**- 最坏情况: 任意输入规模的最大运行次数(上界)

平均情况: 任意输入规模的期望运行次数
最好情况: 任意输入规模的最小运行次数(下界)**

大 O 的渐进表示法在实际中一般情况关注的是算法的上界，也就是最坏运行情况。

4.5 实例5

cs 复制代码

// 计算BubbleSort的时间复杂度?
void BubbleSort(int* a, int n)
{
    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;
    }
}

BubbleSort执行的基本操作次数:

若数组有序，则:
T(N) = N
若数组有序且为降序，则:
T(N) = (N*(N+1))/2

因此: BubbleSort的时间复杂度取最差情况为**: O(N^2)**

4.6 实例6

cs 复制代码

//计算Fun5函数的时间复杂度?
void Func5(int n)
{
    int cnt = 1;
    while (cnt < n)
    {
        cnt *= 2;
    }
}

当 n=2 时，执行次数为 1

当 n=4 时，执行次数为 2

当 n=16 时，执行次数为 4

假设执行次数为 x ，则 2^x = n

因此执行次数：x = log₂n

因此： func5 的时间复杂度取最差情况为： O(log₂n)

当 n 接近无穷大时，底数的大小对结果影响不大。因此，一般情况下不管底数是多少都可以省略不写，即可以表示为 log n ,也建议使用 log n

4.7 实例7

cs 复制代码

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

计算递归函数的复杂度时,核心是: 递归调用次数 * 单词递归的时间复杂度

调用一次 Fac 函数的时间复杂度为 O(1)

而在 Fac 函数中，存在 n 次递归调用 Fac 函数

因此：

阶乘递归的时间复杂度为： O(n)

以上这些实例基本上变式计算时间复杂度的所有方法，除此之外，计算时间复杂度都是在这些实例

的基础上进行加以计算。希望大家能够深刻理解这些实例以及计算过程。

我们之前已经讲了关于C语言的全部内容。在这里我想说的是，C语言是工具，提供语法、内存操

作等能力，让你能把数据结构"写出来"；数据结构是组织数据的模式。

用C语言的语法、功能，去实现数据结构的逻辑；数据结构让C语言写的程序，能更高效存、取、

处理数据，解决复杂问题。

本篇的内容先讲到这里, 后面小编会逐篇的更新关于数据结构的详细内容。觉得小编写的不错的可

以点个关注。感谢大家的观看，谢谢大家的支持！

数据结构 算法复杂度(1)

1.数据结构前言

1.1 数据结构

1.2 算法

1.3 算法和数据结构的关系

2.复杂度

3.时间复杂度

3.1 大O的渐进表示法

4.时间复杂度计算实例

4.1 实例1

4.2 实例2

4.3 实例3

4.4 实例4

4.5 实例5

4.6 实例6

4.7 实例7

数据结构算法复杂度(1)