数据结构细致解析（算法的时间复杂度和空间复杂度）

目录

1.数据结构篇幅 

数据结构的重要性

了解基本术语

数据结构的概念

结构数据的存储  

数据的逻辑结构 存储结构及运算的关系

2.算法的时间复杂度和空间复杂度 

算法效率

时间复杂度

空间复杂度

常见时间复杂度以及复杂度oj练习 

 3.静态搜索问题

顺序搜素

二分查找

插值搜索

---

1.数据结构篇幅 

1.1 数据结构的重要性

  1.数据结构是随着计算机的发展而出现的一门较新的计算机课程（数据结构是计算机专业的核心课程之一。在众多的计算机系统软件和应用软件中都要用到的各种数据结构）

首先什么是数据结构：

数据结构（Date Structure）就是计算机存储组织数据的方式，指相互之间存在一种或多种特定关系的数据元素集合。

1.2 了解基本术语

•  数据（data）信息的载体，它是描述客观事物的数，字符以及所有能输入到计算机中被计算机程序识别，加工处理的信息的集合。
• 数据项（ data item ) 是数据具有独立意义的不可分的最小单位，它是对数据的数据元素属性的描述。数据项也被称为字段或域。
• 数据元素（ data element ) 是数据的基本单位是对一个客观实体的数据描述。一个数据元素可以由一个或若干个数据项组成 。数据元素也被称为结点或记录。

 以表格为例子：

学号	姓名	数学	语文	英语
S01012	张扬	85	69	92
S01022	王海	87	73	74
S01024	李强	92	64	84

视图理解：

 数据对象（ data object ）是具有相同性质的数据元素的集合，它是数据的一个子集。 例如，集合（1,2,3,4,5,.）是自然数的数据对象，而集合（ a , b . c , d ,...,）是英文字母表的数据对象。可以看出，数据对象可以是无限的，也可以是有限的。

数据类型（ data type ) 是具有相同性质的计算机数据的集合及定义在这个数据集合上的一组操作的总称。数据类型封装了数据存储与操作的具体细节。

数据类型可分为两类：原子类型 和 结构类型

原子类型：如果一个数据元素由一个数据项组成，这个数据元素的类型就是这个数据项的原子类型，值在逻辑上不可分解（如 int i , float j )。
结构类型：如果由多个不同类型的数据项组成，则这个数据元素的类型就是由各数据项类型构造而成的结构类型，值由若干成分按某种结构组成，如 struct stu 。上面提到的学生成绩表中，数据项姓名的数据类型为字符型，而成绩的数据类型是整型的，所以这个数据元素是一个结构类型。上述成绩表数据用 C 语言的结构体数组 Class1stu [50］来存储。 

struct stu 

{/*数据项*/

int stuID;

char name[20];

int maths_score;

int chinese_score;

int englishs_score;

}Class1stu[50]

• 不同的高级语言提供的基本数据类型有所不同，在C语言中，提供了实型，整数，字符型和指针型等基本数据类型。

1.3 数据结构的概念 

简单地说，数据结构指的是数据之间的相互关系，即数据的组织形式。一般包括以下3个方面的内容：
(1）数据之间的逻辑关系，也称为数据的逻辑结构。
根据数据逻辑关系的不同，可分为以下4种基本结构类型。
集合：数据具有符合某一条件的相同的性质，且无其他关系。例如自然数的全体，实数域的全体等。
线性结构：数据之间存在一对一的关系。例如常见的线性表就是一个例子。
树状结构：数据之间存在一对多的关系。生活中的亲缘关系，一对夫妇和他们的全部子孙构成一个树状结构。
网状结构：数据之间存在多对多的关系。
(2）存储结构：数据元素及其关系在计算机存储器内的表示，称为数据的存储结构，也就是物理结构。
(3）数据的运算，即对数据进行的操作。

1.4 结构数据的存储 

数据的存储结构

1. 顺序存储方法

        该方法是将逻辑上相邻的结点存储在物理位置上也相邻的存储单元里，结点之间的逻辑关系由存储单元的邻接关系来表示（也就是说，只存储结点的值，不存储结点之间的关系）这种存储表示称为顺序存储结构。它主要应用于线性的数据结构，非线性的数据结构也可以通过某种线性化的过程后，进行顺序存储。
顺序存储结构的主要特点如下：
(1）结点中只有自身信息域，没有连接信息域。因此存储密度大，存储空间利用率高。
(2）可以通过计算直接确定数据结构中的第 i 个结点的存储地址 Li ，计算公式为
                                              L i= L 0十（ i -1)* m 
其中 L0 为第一个结点的存储位置、m为每个结点所占用的存储单元个数。

（3）插入的删除都会引起大量的结点移动 

练习： 

     例 1 - 1 有一数据结构如下

A = (D , S)

D = {a,b,c,d,e}

S = {<a,b>,<b,c>,<c,d>,<d,e>}

设一个结点的存储单元位置为 1000，每一个结点所占的存储单元的个数为1。

2. 链式存储方式

        链式存储方法不要求逻辑上相邻的结点在物理位置上也相邻，结点间的关系由附加的指针来表示，指针指向结点的邻接结点，这样将所有结点串联在一起，称为链式存储结构，也就是说，链式存储方法不仅存储结点的值，而且还存储结点之间的联结关系。
          所以，链式存储方法中的结点由两部分组成，一个是存储结点本身的值，称从数据城；另一个是存储该结点的各后继结点的存储单元地址，称为指针域（可包含一个或多个指针）
链式存储结构的主要特点如下：
(1）结点中除具有本身信息外，还有表示链接信息的指针域，因此比顺序存储结构的存储密度小，存储空间利用率低。

(2）逻辑上相邻的结点，物理上不必邻接，可用于线性表、树、图等多种逻辑结构的存储表示。

(3）删除和插入操作灵活方便，不必移动结点，只要改变结点中的指计值即可。
          这种存储结构将在后面的章节中详细讲述，在这里只举一个简单例子说明。
例1-2  假设存在这样一个线性结构的结点集合 D ={45,63,67,14,97} 以结点值的降序为关系 S ={<97,67>,<67,63>,<63,45>,<45,14>} 

链接存储结构如图

                                  地址                            数据                      指针

1000	45	1003
1001	63	1000
1002	67	1001
1003	14	^
1004	97	1002

                                                          （a）存储结构

                                                            (b)逻辑结构

1.5 数据的逻辑结构 存储结构及运算关系

      数据的逻辑结构、效据的存储结构及效据的运算三者融为一个整体。狐立地理解一个方面，而不注意它们之间的联系是不可取的。
      存储结构是数据结构不可缺少的一个方面，同一逻辑结构的不同存储结构可以不同的数据结构名称来标识。
      例如，线性表是一种逻辑结构，若采用顺序存储方法，可称其为顺序表；若采用链式存储方法，则可称其为链表；若采用散列存储方法，则可称为散列表。
       效据的运算也是效据结构不可分割的一个方间。在给足了数据的逻辑结构和存储结构之后，若定义的运算集合及其运算的性质不同，也可能导致完全不同的数据结构。
       例如，若对性表上的插人、删除运算限制在表的一端进仃，则该线性表称之为栈；若对插人限制在表的一端进行，而删除限制在表的另一端进行，则该线性表称之为队列。更进一步，若线性表采用顺序表或链表作为存储结构，则对插人和删除运算做了上述限制之后，可分别得到顺序栈或链栈，顺序队列或链队列。

2.算法的时间复杂度和空间复杂度

2.1 算法效率

2.1.1 如何衡量一个算法的好坏

如何衡量一个算法的好坏呢？比如对于以下斐波那契数列：

long long Fib(int N)
{
	if (N < 3)
		return 1;

	return Fib(N - 1) + Fib(N - 2);
}

斐波那契数列的递归实现方式非常简洁，但简洁一定好吗？那该如何衡量其好与坏呢？

2.1.2 算法的复杂度

算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源 。因此衡量一个算法的好坏，一般 是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。

时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。在计算 机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计 算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。

2.1.2 时间复杂度

时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一 个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知

道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个 分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。

即：找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。

// 请计算一下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;
	}
	printf("%d\n", count);
}

 

 2.2.2  大O的渐进表示法

大O符号（Big O notation）：是用于描述函数渐进行为的数学符号

推导大O阶方法：

1、用常数1取代运行时间中的所有加法常数。

2、在修改后的运行次数函数中，只保留最高阶项。

3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。 使用大O的渐进表示法以后，Func1的时间复杂度为：     

                                                                           O(N 2)

• N = 10  F(N) = 100
• N = 100 F(N) = 10000
• N = 1000 F(N) = 1000000

通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。 另外有些算法的时间复杂度存在最好、平均和最坏情况：

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

平均情况：任意输入规模的期望运行次数

最好情况：任意输入规模的最小运行次数(下界)

例如：在一个长度为N数组中搜索一个数据x

最好情况：1次找到

最坏情况：N次找到

平均情况：N/2次找到

在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)

2.2.3 常见时间复杂度计算举例

实例：

//实例一
// 计算Func2的时间复杂度？
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);
}
//实例二
// 计算Func3的时间复杂度？
void Func3(int N, int M)
{
	int count = 0;
	for (int k = 0; k < M; ++k)
	{
		++count;
	}
	for (int k = 0; k < N; ++k)
	{
		++count;
	}
	printf("%d\n", count);
//实例三
	// 计算Func4的时间复杂度？
	void Func4(int N)
	{
		int count = 0;
		for (int k = 0; k < 100; ++k)
		{
			++count;
		}
		printf("%d\n", count);
	}

实例答案及分析：

1. 实例1基本操作执行了2N+10次，通过推导大O阶方法知道，时间复杂度为 O(N)

2. 实例2基本操作执行了M+N次，有两个未知数M和N，时间复杂度为 O(N+M)

3. 实例3基本操作执行了10次，通过推导大O阶方法，时间复杂度为 O(1)

2.3 空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度 。

空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。 空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。

注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因 此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

实例：

	//实例一
	// 计算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;
		}
	}
	//实例二
	// 计算Fibonacci的空间复杂度？
// 返回斐波那契数列的前n项
	long long* Fibonacci(size_t 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;
	

 实例答案及分析：

1. 实例1使用了常数个额外空间，所以空间复杂度为 O(1)

2. 实例2动态开辟了N个空间，空间复杂度为 O(N)

2.4.常见复杂度对比以及复杂度的oj练习

2.4.1 常见复杂度对比

2.4.2 消失的数字OJ链接：https://leetcode-cn.com/problems/missing-number-lcci/

 

 

 

 

 

//思路一
int missingNumber(int* nums, int numsSize)
{
	int N = numsSize;
	int ret = N * (N + 1) / 2;
	for (int i = 0; i < numsSize; i++)
	{
		ret -= nums[i];
	}
	reture ret;
}

//思路三
int missingnumber(int* nums, int numssize) {
    int n = numssize;
    int x = 0;
    for (int i = 0; i < numssize; i++)
     {
         x ^= nums[i];
     }

    for (size_t j = 0; j <= n; j++)
     {
         x ^= j;
     }
    return x;
}