1.1数据结构概述
数据结构是数据元素的集合，它研究的是数据的逻辑结构和数据的物理结构以及它们之间的相互关系，并对这种结构定义相适应的运算，设计出相应的算法，并确保经过这些运算以后所得到的新结构仍保持原来的结构类型。简而言之，数据结构是相互之间存在一种或多种特定关系的数据元素的集合，即带“结构”的数据元素的集合。“结构”就是指数据元素之间存在的关系，分为逻辑结构和存储结构。
1.2数据结构的基本概念
数据：程序的操作对象，用于描述客观事物，是所有能被输入到计算机中，且能被计算机处理的符号的集合，包括数值，图片，视频等。
数据对象:性质相同的数据元素的集合，是数据的子集(类似于数组)。例如所有人的身份信息可以作为一个数据对象。
数据元素：是组成数据的,且有一定意义的基本单位,在计算机中通常作为整体处理. 也被称作"记录"。例如每一个人的身份信息可能就是一个数据元素。
数据项：一个数据元素由若干数据项组成，是组成数据元素的最小单位。在身份信息中，有姓名、有身份证编号，这样的信息就是数据元素中的数据项。
数据结构：是数据的组织形式，数据元素之间存在的一种或多种特定关系的数据元素集合。
数据类型：是一组值的集合和定义在该集合上的操作的总和。其中有原子类型，原子就是不可再分割的意思，它是原子类型值的集合和定义在该集合上的操作。例如在 C 语言中的 int、char、float 等都是原子类型。除了原子类型，还有结构类型，它是结构的集合和定义在集合上的操作。结构就是多个原子类型值的组合，其中有 list、map、set 等。最后还有抽象数据类型，它是数据模型以及定义在该数据模型上的操作，可以用一个三元组来表示，分别是数据对象、数据关系和相关的操作。对于抽象数据类型，只考虑它的逻辑特性，具体的内部实现是不考虑的。例如在生活中所有的人、汽车都可以把它抽象出来作为一种抽象数据类型。
关系如下图：
这是一张成绩单，如果把这张成绩单叫做一个数据对象的话，那么每一个人的姓名可以称作为一个数据项，而每一个人所有的信息是一个数据元素。这张表还有类似于小明排在小红前面这样的关系，这样的关系就是所说的结构。
代码片段如下：
/*
数据: 程序的操作对象,用于描述客观事物.
数据的特点: 1️⃣ 可以输入到计算机 2️⃣ 可以被计算机处理
数据项: 一个数据元素由若干数据项组成
数据元素: 组成数据的对象的基本单位
数据对象: 性质相同的数据元素的集合(类似于数组)
结构: 数据元素之间不是独立的,存在特定的关系.这些关系即是结构;
数据结构:指的数据对象中的数据元素之间的关系
*/
#include
//声明一个结构体类型
struct Teacher{ //一种数据结构
char *name; //数据项--名字
char *title; //数据项--职称
int age; //数据项--年龄
};
int main(int argc, const char * argv[]) {
struct Teacher t1; //数据元素;
struct Teacher tArray[10]; //数据对象;
t1.age = 18; //数据项
t1.name = "CC"; //数据项
t1.title = "讲师"; //数据项
printf("老师姓名:%s\n",t1.name);
printf("老师年龄:%d\n",t1.age);
printf("老师职称:%s\n",t1.title);
return 0;
}
1.3逻辑结构与物理结构
根据视角不同,我们将数据结构分为2种: 逻辑结构与物理结构;
1.3.1逻辑结构
逻辑结构是指数据元素之间的逻辑关系，它更贴近于现实，即从逻辑关系上来描述数据。它是独立于计算机的，与计算机内部如何存储是无关的。
在逻辑结构中，具体分为四种：线性结构、集合、树形结构、图状结构。其中，把集合、树形结构、图状结构统称为非线性结构。
集合是指除了所有的元素均在一个集合之内，之外再无其他的关系。在数学中，所有整数就是一个集合，所有的小数也是一个集合。
2.线性结构
线性结构中的数据元素之间是一对一的关系，如线性表，栈，队列，数组，字符串等。
3.树形结构
重要的非线性数据结构。树形数据结构可以表示数据表素之间一对多的关系.树型结构中的数据元素之间存在一种一对多的层次关系。包括二叉树,B树,哈夫曼树,红黑树等
4.图形结构
也叫做网状结构，它是多对多的关系。比如城市的交通网络，每一个城市都连接这其他的许多城市。
1.3.2物理结构
物理结构是指数据结构在计算机内的表示，也称为存储结构。它既包括数据元素本身的表示，也包括数据元素之间关系的表示。数据存储结构应该正确反映数据元素之间的逻辑关系.这才是关键! 如何存储数据元素之间的逻辑关系,是实现物理结构的重点和难点.
数据元素的存储结构也分为四种：顺序存储、链式存储、索引存储、散列存储。
2.链式存储结构：是把数据元素放在任意的存储单元里,这组存储单元可以是连续的,也可以是不连续的. 数据元素的存储关系并不能反映逻辑关系,因此需要用一个指针存放数据元素的地址,这样通过地址就可以找到相关关联数据元素的位置.
3.索引存储结构：索引存储在内存中不仅仅要存放每一个数据元素，还要建立一张索引表。在索引表中有一个个索引项，每一个索引项都存放两个信息，一个是关键字，另一个是该关键字查找数据对应的地址。一个个索引项可以非常快速的找到对应存储数据的地址。
但是，索引存储有一个缺点，就是既要存放数据元素，又要存放索引表，在存放索引表的时候会消耗内存资源。
4.散列存储：也称为哈希存储，它是通过关键字的相应函数运算直接求得对应数据元素的地址，它的查找速度也是非常快的。
总结 逻辑结构是面向问题的,而物理结构就是面向计算机的. 其基本的目标就是将数据以及逻辑关系存储到计算机的内存中.
2算法
对特定问题求解步骤的一种描述，它是指令的有限序列，其中的每条指令表示一个或多个操作。
1.数据结构和算法的关系
两者基友联系又有区别。联系是程序=算法+数据结构。数据结构是算法实现的基础，算法总是要依赖某种数据结构来实现的。算法的操作对象是数据结构。区别是数据结构关注的是数据的逻辑结构、存储结构有一集基本操作，而算法更多的是关注如何在数据结构的基本上解决实际问题。算法是编程思想，数据结构则是这些思想的基础。
2.算法的特性
有穷性：一个算法必须在执行有穷步之后结束，且每一步都必须在有穷时间内完成。如果有类似无限循环的语句，那么就不能称之为算法。
可行性：一个算法是可行的，即算法中描述的操作都是可以通过已经实现的基本运算执行有限次来实现的。每一步操作都是可以实现的才能称之为算法。
确定性：算法中每条指令、每条语句必须有确切的含义，相同的输入必须得出到相同的输出，不能产生二义性。
输入：一个算法必须有零个或多个输入。
输出：一个算法必须有一个或多个输出。
2.1算法的效率
1.正确性：应该能够正确的解决问题。
2.可读性：算法应具有良好的可读性，以帮助人们理解。在人们修改阅读算法时，人们应能够快速的理解掌握该算法。
3.健壮性：健壮性是指在输入非法数据时，算法能适应的做出反应或进行处理。
4.时间效率高和存储量低：效率是指算法执行时间，存储量需求是指算法执行过程中所需最大存储空间。这是最常用的用来考量一个好的算法的标准。也就是时间复杂度与空间复杂度。
2.2算法时间复杂度
在进行算法分析时,语句的总执行次数T(n)是关于问题规模n的函数. 进而分析T(n)随着n变化情况并确定T(n)的数量级. 算法的时间复杂度,也就是算法的时间量度. T(n) = O(f(n)).
“它表示随问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称作算法的渐近时间复杂度，简称为时间复杂度。其中f(n)是问题规模n的某个函数。”
大写O( )来体现算法时间复杂度的记法，我们称之为大O记法。
算法的时间复杂度是衡量一个算法好坏的重要指标。一般情况下，随着规模n的增大，次数T(n)的增长较慢的算法为最优算法。常见时间复杂度有常数阶 O(1)、 线性阶 O(n)、平方阶 O(n^2)、 对数阶 O(logn)、立方阶 O(n^3)、 nlog阶 O(nlogn)
-
指数阶(不考虑) O(2^n)或者O(n!) 除非是非常小的n,否则会造成噩梦般的时间消耗. 这是一种不切实际的算法时间复杂度. 一般不考虑!从小到大依次排列：O(1) < O(log2n) < O(n) < O(n²）
常见的算法时间复杂度.jpg
举个例子，看下面3个代码：
1、{++x;}
2、for(i = 1; i <= n; i++) { ++x; }
3、for(j = 1; j <= n; j++)
for(j = 1; j <= n; j++)
{ ++x; }
上述含有 ++x 操作的语句的频度分别为1 、n 、n^2，
假设问题的规模扩大了n倍，3个代码的增长率分别是1 、n 、n^2
它们的时间复杂度分别为O(1)、O(n )、O(n^2)
2.21时间复杂度的计算方法
1.用常数1取代运行时间中所有加法常数;
2.在修改后的运行次数函数中,只保留最高阶项;
3.如果在最高阶项存在且不是1,则去除与这个项相乘的常数;
2.22常见的时间复杂度
1.常数阶
//1+1+1 = 3 O(1)
void testSum1(int n){
int sum = 0; //执行1次
sum = (1+n)*n/2; //执行1次
printf("testSum1:%d\n",sum);//执行1次
}
//1+1+1+1+1+1+1 = 7 O(1)
void testSum2(int n){
int sum = 0; //执行1次
sum = (1+n)*n/2; //执行1次
sum = (1+n)*n/2; //执行1次
sum = (1+n)*n/2; //执行1次
sum = (1+n)*n/2; //执行1次
sum = (1+n)*n/2; //执行1次
printf("testSum2:%d\n",sum);//执行1次
}
//x=x+1; 执行1次
void add(int x){
x = x+1;
}
这个算法的运行次数函数是f(n) = 3;根据我们大O时间复杂度表示,第一步先把常数项改成1. 在保留最高阶时发现,它根本没有最高阶. 所以这个算法的视觉复杂度为O(1);
2.线性阶
/*2.线性阶时间复杂度*/
//x=x+1; 执行n次 O(n)
void add2(int x,int n){
for (int i = 0; i < n; i++) {
x = x+1;
}
}
//1+(n+1)+n+1 = 3+2n -> O(n)
void testSum3(int n){
int i,sum = 0; //执行1次
for (i = 1; i <= n; i++) { //执行n+1次
sum += i; //执行n次
}
printf("testSum3:%d\n",sum); //执行1次
}
3.对数阶
/*3.对数阶*/
/*2的x次方等于n x = log2n ->O(logn)*/
void testA(int n){
int count = 1; //执行1次
//n = 10
while (count < n) {
count = count * 2;
}
}
4.平方阶
/*4.平方阶*/
//x=x+1; 执行n*n次 ->O(n^2)
void add3(int x,int n){
for (int i = 0; i< n; i++) {
for (int j = 0; j < n ; j++) {
x=x+1;
}
}
}
//n+(n-1)+(n-2)+...+1 = n(n-1)/2 = n^2/2 + n/2 = O(n^2)
//sn = n(a1+an)/2
void testSum4(int n){
int sum = 0;
for(int i = 0; i < n;i++)
for (int j = i; j < n; j++) {
sum += j;
}
printf("textSum4:%d",sum);
}
//1+(n+1)+n(n+1)+n^2+n^2 = 2+3n^2+2n -> O(n^2)
void testSum5(int n){
int i,j,x=0,sum = 0; //执行1次
for (i = 1; i <= n; i++) { //执行n+1次
for (j = 1; j <= n; j++) { //执行n(n+1)
x++; //执行n*n次
sum = sum + x; //执行n*n次
}
}
printf("testSum5:%d\n",sum);
}
5.立方阶
/*5.立方阶*/
void testB(int n){
int sum = 1; //执行1次
for (int i = 0; i < n; i++) { //执行n次
for (int j = 0 ; j < n; j++) { //执行n*n次
for (int k = 0; k < n; k++) {//执行n*n*n次
sum = sum * 2; //执行n*n*n次
}
}
}
}
2.3算法空间复杂度
空间复杂度（space complexity）作为算法所需存储空间的量度，记做S(n) = O (f(n))。其中，n为问题的规模；f（n）为语句关于n的所占存储空间的函数。
一般情况下，一个程序在机器上运行时，除了需要存储程序本身的指令、常数、变量和输入数据外，还需要存储对数据操作的存储单位。若输入数据所占空间只取决于问题本身，和算法无关，这样只需要分析该算法在实现时所需的辅助单元即可。若算法执行时所需的辅助空间相对于输入数据量而言是个常量，则称此算法为原地工作，空间复杂度为O(1)。
程序空间计算因素:
- 寄存本身的指令
- 常数
- 变量
- 输入
- 对数据进行操作的辅助空间
在考量算法的空间复杂度,主要考虑算法执行时所需要的辅助空间.
空间复杂度计算:
//问题: 数组逆序,将一维数组a中的n个数逆序存放在原数组中.
#include
int main(int argc, const char * argv[]) {
// insert code here...
printf("Hello, World!\n");
int n = 5;
int a[10] = {1,2,3,4,5,6,7,8,9,10};
//算法实现(1)
int temp;
for(int i = 0; i < n/2 ; i++){
temp = a[i];
a[i] = a[n-i-1];
a[n-i-1] = temp;
}
for(int i = 0;i < 10;i++)
{
printf("%d\n",a[i]);
}
//算法(1),仅仅通过借助一个临时变量temp,与问题规模n大小无关,所以其空间复杂度为O(1);
//算法实现(2)
int b[10] = {0};
for(int i = 0; i < n;i++){
b[i] = a[n-i-1];
}
for(int i = 0; i < n; i++){
a[i] = b[i];
}
for(int i = 0;i < 10;i++)
{
printf("%d\n",a[i]);
}
return 0;
}
算法(2),借助一个大小为n的辅助数组b,所以其空间复杂度为O(n).
注意,算法的空间复杂度指的并不是整个算法在内存占用空间,而是指的是该算法在实现时所需要的辅助空间就可以