数据结构分为物理结构和逻辑结构，逻辑结构分为线性结构、集合结构、树形结构和图形结构。线性表就属于线性结构，线性表是最基本、最简单、也是最常用的一种数据结构。

线性表

线性表的性质

线性表 就是具有像线一样的性质的表。它是由零个或多个数据元素组成的有限序列。当线性表的长度为0时，称为空表。

在稍复杂的线性表中，一个数据元素可由多个数据项组成，此种情况下常把数据元素称为记录，含有大量记录的线性表又称为文件。

1
2
3
4
5

graph LR
数据元素1-.-数据元素2
数据元素2-.-数据元素3
数据元素3-.-...
数据元素n-.-...

线性表中数据元素之间的关系是一对一的关系，
数据元素1是线性表的第一个元素，只有一个直接后继。
数据元素n是线性表的最后一个元素，只有一个直接前驱。
除数据元素1和数据元素n的其他数据元素，既有直接前驱，也有直接后继，并且有且只有一个。

线性表的特点

• 线性表存储的数据是同类型的
• 线性表中各数据元素之间的相对位置是固定的

线性表的分类

逻辑结构上相邻的数据在实际的物理存储中有两中形式：分散存储和集中存储。

跟据这两种形式线性表可分为两种：

• 数据元素在内存中集中存储，采用顺序存储结构，简称“顺序存储”，也称顺序表
• 数据元素在内存中分散存储，采用链式表示结构，简称“链式存储”，也称链表

线性表的顺序存储结构

线性表的顺序存储结构是用一段地址连续的存储单元依次存储线性表的数据元素。

顺序表一般使用数组实现，事实上就是在内存中找个初始地址，然后通过占位的形式，把一定连续的内存空间给占了，然后把相同数据类型的数据元素依次放在这块空地中，数组大小有两种方式指定，一是静态分配，二是动态扩展。

注：数组的长度是存放线性表的存储空间的长度，存储分配后这个量一般是不变得。线性表的长度是线性表中数据元素的个数，随着线性表的插入和删除操作的进行，这个量是变化的。线性表的长度应该小于等于数组的长度。

顺序表的顺序存储表示

1
2
3
4
5
6
7
8

//----- 顺序表的顺序存储表示 -----
typedef  int  ElemType;
typedef struct {
ElemType*elem;// 存储空间的基址
    int length; // 表长
    int size;// 存储容量
int increment; // 扩容时，增加的存储容量
} SqList;  //顺序表

使用顺序存储结构需要四个属性：

• 存储空间的起始位置：指针elem,它存储的位置就是存储空间的存储位置
• 顺序存储表的最大存储容量：size
• 顺序存储表的当前长度：length
• 顺序存储表扩容时增加的容量：increment

顺序表的创建

1
2
3
4
5
6
7
8

Status InitSqlist(SqList &L){
L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
if(!L.elem) exit (OVERFLOW);         //返回空指针则退出程序
L.length = 0;                       // 空表长度为0
L.size = LIST_INIT_SIZE;             // 初始存储容量
L.increment = LISTINCREMENT;
return OK;
}

void malloc(unsigned int num_bytes)：动态内存分配，用于申请一块连续的指定大小的内存块区域，void 表示未确定类型的指针，void * 可以指向任何类型的数据，更明确的说是指申请内存空间时还不知道用这段空间来存储什么类型的数据。如果分配内存成功则函数返回被分配内存的指针，否则返回空指针NULL。当内存不再使用时，应使用free()函数将内存块释放。

顺序表的的初始化操作就是为了顺序表分配一个预定义大小的数组空间，并将线性表的当前长度设为“0”。

顺序表的插入

插入算法的思路：

• 如果插入位置不合理，抛出异常
• 如果线性表长度大于等于数组长度，则抛出异常或动态增加容量
• 从最后一个元素开始向前遍历到第i个位置，分别将它们都向后移动一个位置
• 将要插入元素填入位置i处
• 表的长度

示例

当前有一个长度为7的顺序表

在顺序表第三的位置上插入一个元素“8”，因此当前顺序表的第三个元素及其以后的所有元素要向后移动一位，从顺序表的表尾开始

1
2

graph LR
8

当移动完成后，元素“8”插入顺序表的第三个位置上。顺序表的长度增加1。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

//顺序表插入函数
Status ListInsert_Sq(SqList &L, int i ,ElemType e){
int j;  
   if(i<1 || i>L.length+1) {      //对i的合法性判断
printf("\n插入位置不合法！，i值必须大于等于1，小于等于%d\n",L.length+1);
return ERROR;
}      
   
   if(L.length>=L.size) {        //对顺序表是否满判断 
       //当前存储空间已满，增加分配
      L.elem = (ElemType *)realloc(L.elem, (L.size + LISTINCREMENT)*sizeof(ElemType));
if(NULL == L.elem)       //分配内存失败，退出程序
    return  OVERFLOW;
L.size += LISTINCREMENT;     //增加存储容量
   }
  
   for(j=L.length-1;  j>=i-1;  j--){
   L.elem[j+1]=L.elem[j];    //插入位置及之后的元素后移
   } 
   
L.elem[i-1]=e;               //将新元素e放入第i个位置
    ++L.length;          //表长增1
  return OK;
}

void realloc(void ptr, size_t new_Size ) 用于对动态内存进行扩容（及已申请的动态空间不够使用，需要进行空间扩容操作），ptr为指向原来空间基址的指针，new_size为接下来需要扩充容量的大小。

执行realloc函数的几种情况

• 如果当前内存段后面有需要的内存空间，则直接扩展这段内存空间，realloc()将返回指向原地址的指针。
• 如果当前内存段后面的空闲字节不够，那么就是用堆中的第一个能够满足这一要求的内存块，将目前的数据复制到新的位置，并将原来的数据块释放掉，返回新的内存块位置。
• 如果申请失败，将返回NULL，此时，原来的指针仍然有效。

注：如果调用成功，不管当前内存段后面的空闲空间是否满足要求，都会释放掉原来的指针

顺序表插入操作的时间复杂度为O(n)。

顺序表的按位获取元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14

ElemType ListQuery_Sq(SqList L,int i){
ElemType e;
if(i<1 || i>L.length+1) {    //对i的合法性判断
printf("\n查询位置不合法！，i值必须大于等于1，小于等于%d\n",L.length+1);
return ERROR;
}      
if (L.length!=0) {  //判断顺序表是否为空表
e=L.elem[i-1];
return e;
}else {
printf("\n这是个空表\n");
return ERROR;
}
}

顺序表本质是一个数组，利用数组的下标，可以获取到顺序表的元素。数组下标从0开始，顺序表位置从1开始，所以在获取顺序表中的元素，需要（i-1）才是数组的下标。

顺序表按位查找操作的时间复杂度为O(1)。

顺序表的删除

删除算法的思路：

• 如果删除位置不合理，抛出异常
• 取出删除元素
• 从删除元素位置开始遍历到最后一个元素位置，分别将它们都向前移动一个位置
• 表的长度减少1

示例

当前是一个长度为8的顺序表，我们要删除第三个位置上的元素。我们只需要将第四个位置上的元素覆盖掉第三个位置上的元素，第五个位置上的元素覆盖掉第四个位置上的元素，依此类推，直到执行至表尾。

执行完删除操作后，顺序表的长度减1.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

//顺序表删除元素函数
Status ListDelete_Sq(SqList &L, int i, ElemType  &e){
   //请在此填写代码，将该算法补充完整
   int j;
   if((i<1)||(i>L.length)) {
   printf("\n删除位置不合法！，i值必须大于等于1，小于等于%d\n",L.length);
   return ERROR; //i值不合法
   }
   e = L.elem [ i -1];
   for (j=i;  j<=L.length-1;  j++)                   
   L.elem[j-1]=L.elem[j]; //被删除元素之后的元素前移   
   --L.length;                     //表长减1
  return OK;
}

一般情况下，删除第i个元素时需要将从第i+1至第n个元素依次向前移动一个位置。

顺序表删除操作的时间复杂度为O(n)。

线性表顺序存储结构的优缺点

优点：

• 无须为表示表中元素之间的逻辑关系而增加额外的存储空间
• 可以快速的存取表中任一位置的元素

缺点

• 插入和删除操作需要移动大量元素
• 当线性表长度变化较大时，难以确定存储空间容量
• 造成存储空间的“碎片”

服务器，也称伺服器。指一个管理资源并为用户提供服务的计算机设备。根据服务器提供的服务类型不同，可分为文件服务器，数据库服务器，应用程序服务器，WEB服务器等。

代理服务器

代理服务器 是介于浏览器和Web服务器之间的一台服务器，它的功能是代理网络用户取得网络信息。可以形象的称为网络信息的中转站。

完整的代理请求过程

客户端首先与代理服务器创建连接，接着根据代理服务器所使用的代理协议，请求对目标服务器创建连接、或者获得目标服务器的指定资源。

代理服务器可能对目标服务器的资源下载至本地缓存，如果客户端所要获取的资源在代理服务器的缓存之中，则代理服务器不会向目标服务器发送请求，而是直接返回缓存了得资源。

1
2
3
4
5

sequenceDiagram
    客户端->>代理服务器: 发送请求
    代理服务器-->>服务器: 转发请求
    服务器-->>代理服务器: 返回结果，代理服务器下载资源
    代理服务器->>客户端: 返回结果

注：实线是表示客户端与代理服务器端同属一个内网中。

代理服务器的主要功能

1.突破自身IP访问限制，访问国外站点。2.访问一些单位或团体内部资源，如某大学FTP（前提是该代理地址在资源的允许访问范围之内），使用教育网内地址段免费代理服务器，就可以用教育网开放的各类FTP下载上传，以及各类资料查询共享等服务。3.提高访问速度：通常代理服务器都设置一个较大的硬盘缓冲区，当有外界的信息通过时，同时也将其保存到缓冲区中，当其他用户再访问相同的信息时，则直接由缓冲区中取出信息，传给用户，以提高访问速度。4.隐藏真实IP：上网者也可以通过这种方法隐藏自己的IP，免受攻击。代理服务器还可以改变客户端的原始请求、目标服务器的原始响应。5.防火墙作用：由于所有的客户机请求都是必须通过代理服务器访问远程站点，因此可以在代理服务器上设限，过滤某些不安全信息。

常用的代理技术

实现代理技术，常用的方法有：正向代理、反向代理和透明代理三种。

正向代理

正向代理的技术实现方式就是代理服务器，又叫做转发代理服务器。

正向代理是一个位于客户端和原始服务器(origin server)之间的服务器，为了从原始服务器取得内容，客户端向代理发送一个请求并指定目标(原始服务器)，然后代理向原始服务器转交请求并将获得的内容返回给客户端。

注：客户端必须设置正向代理服务器，当然前提是要知道正向代理服务器的IP地址，还有代理程序的端口。

代理服务器软件————CCProxy的应用场景

CCProxy的功能介绍

1.代理共享上网。只要局域网内有一台机器能够上网，其他机器就可以通过这台机器上安装的CCProxy来代理共享上网，最大程度的减少了硬件费用和上网费用。
2.客户端代理权限管理。只需要在服务器上CCProxy代理服务器软件里进行账号设置，就可以方便的管理客户端代理上网的权限。提高了员工工作效率和企业信息安全管理。

反向代理

反向代理与正向代理正好相反，对于客户端而言它就像是原始服务器，并且客户端不需要进行任何特别的设置。客户端向反向代理服务器发送请求，反向代理服务器会判断向内网中的某个原始服务器转交请求，并将获得的内容返回给客户端。

1
2
3
4
5

sequenceDiagram
    客户端-->>代理服务器: 发送请求
    代理服务器->>服务器集群: 判断转交给内网中的那个服务器
    服务器集群->>代理服务器: 返回结果
    代理服务器-->>客户端: 返回结果

注：实线是表示服务器与代理服务器端同属一个内网中。

反向代理的功能

1、保证内网的安全，可以使用反向代理提供WAF功能，阻止web攻击。大型网站，通常将反向代理作为公网访问地址，Web服务器是内网。
2、负载均衡，通过反向代理服务器来优化网站的负载。
3、缓存，减少服务器的压力。

反向代理软件——Nginx

Nginx是一款轻量级的Web服务器（高性能的HTTP）/反向代理服务器及电子邮件（IMAP/POP3）代理服务器，并在一个BSD-like协议下发行。其特点是占有内存少，并发能力强，事实上nginx的并发能力确实在同类型的网页服务器中表现较好，中国使用Nginx网站用户有：百度、京东、新浪、网易、腾讯、淘宝等。

正向代理和反向代理的区别

1、位置不同
正向代理，架设在客户机和目标主机之间;
反向代理，架设在服务器端;
2、代理对象不同
正向代理，代理客户端，服务器端不知道实际发起请求的客户端;
反向代理，代理服务端，客户端不知道实际提供服务的服务器端;
3、用途不同
正向代理，为在防火墙的局域网客户端提供访问Internet的途径;
反向代理，将防火墙后面的服务器提供给Internet访问;
4、安全性不同
正向代理允许客户端通过他访问任意网站并且隐藏客户端自身，因此必须采取安全措施以确保仅为授权的客户端提供服务;

透明代理

透明代理是客户端不需要知道有代理服务器的存在，代理服务器会改编客户端请求，但会传送真实的IP。加密的透明代理是属于匿名代理，透明代理与正向代理的请求过程是一样的，唯一不同的是客户端不用再设置使用代理了。

透明代理的应用————行为管理软件

行为管理软件就是管理上网行为的软件。帮助管理者全面了解使用者上网情况和网络使用情况。可以最大限度地避免不当的上网行为带来的潜在风险和损失。

Tomcat与Nginx,apache的区别是什么？

HTTP服务器本质上也是一种应用程序————它通常运行在服务器之上，绑定服务器的IP地址并监听某一个TCP端口来接收并处理HTTP请求，这样客户端（一般来说是IE,Firefox,Chrome这样的浏览器）就能通过HTTP协议来获取服务器上的网页（HTML格式）、文档（PDF格式）、音频(MP4格式)、视频(MOV格式)等资源。

Tomcat与Apache HTTP Server相比，Tomcat能够动态的生成资源并返回到客户端。Apache HTTP Server和Nginx都能够将某一个文本文件的内容通过HTTP协议返回到客户端,但是这个文本文件的内容是固定的。这个文本文件的内容是固定的————也就是说无论何时、任何人访问它得到的内容都是完全相同的，这样的资源我们称之为静态资源。
Apsche HTTP Server和Nginx本身不支持生成动态页面，但它们可通过其他模块来支持（例如通过Shell、PHP、Python脚本程序来动态生成内容）。
如果想要使用java程序来动态生成资源内容，Java Servlet技术以及衍生的Java Server Pages技术可以让Java程序也具有处理HTTP请求并且返回内容（由程序动态控制）的能力，Tomcat正是支持运行Servlet/JSP应用程序的容器（Container）:Tomcat运行在JVM之上，它和HTTP服务器一样，绑定IP地址并监听TCP端口。
虽然Tomcat也可以认为是HTTP服务器，但通常它仍然会和Nginx配合在一起使用:

• 动静态资源分离————运用Nginx的反向代理功能分发请求：所有动态资源的请求交给Tomcat,而静态资源的请求（例如图片、视频、CSS、JavaScript文件等）则直接由Nginx返回到浏览器，这样能大大减轻Tomcat的压力。
• 负载均衡，当业务压力增大时，可能一个Tomcat的实例不足以处理，那么这时可以启动多个Tomcat实例进行水平扩展，而Nginx的负载均衡功能可以把请求通过算法分发到各个不同的实例进行处理。

算法 的优劣主要体现在算法的复杂性上。
算法复杂度 是运行该算法时所占用计算机资源的多少。
计算机资源 主要分为时间和空间资源。

时间复杂度

时间频度 是计算一个程序语句执行的次数，通常情况下时间频度计算的是具体的数值。记作T(n)。

时间复杂度 是算法运行时所占用的时间资源，用来度量算法的运行时间，算法占用的时间短算法效率就高，反之占用的时间长算法的效率就低。时间复杂度记作O(f(n))。

时间复杂度与时间频度的关系：T(n)=O(f(n))

注：时间复杂度不是计算程序的运行时间，时间复杂度实际上就是一个函数，该函数计算的是执行基本操作的次数，与时间频度不同的是它计算的不是具体的数值。

时间复杂度的计算方法

1、若是程序执行次数常数，都是常数阶用O(1)表示。
2、若程序执行次数为不固定项，选取相对执行次数最多的项，也就是最高项。
3、若选取的最高项系数不为1，则最高项系数化为1。

注：1、如果算法的执行时间不随着问题规模n的增加而增长，即使算法中有上千条语句，其执行时间也不过是一个较大的常数。此类算法的时间复杂度是O(1)。    2、当有若干个循环语句时，算法的时间复杂度是由嵌套层数最多的循环语句中最内层语句的频度f(n)决定的。

示例

1
2
3
4
5

　for (i=1; i<=n; i++)
　　       x++;               //执行n次
　for (i=1; i<=n; i++)
　     for (j=1; j<=n; j++)
　　          x++;            //执行n^2次

此段代码的执行次数为n+n^2次，根据时间复杂度的计算方法，选出最高项你n^2，因此时间复杂度为O(n^2)。

常见的时间复杂度

随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。
常见的算法时间复杂度由小到大依次为：
Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜…＜Ο(2^n)＜Ο(n!)

常数阶

1
2
3
4

int test(void) {
    printf("Hello, World!\n");      //  需要执行 1 次
    return 0;       // 需要执行 1 次
}

上面这段代码一共需执行语句2次，是常数，因此是常数阶O(1)。

1
2
3
4
5
6
7
8

int test(void) {
    int x=1;      
    while (x <10)
    {
        x++;      //需要循环执行10次
    }
return 0;     
}

上面这段代码一共需执行语句10次，也是常数，因此也是常数阶O(1)。

对数阶

1
2
3
4

int i = 1, n = 100;
while(i < n){
    i = i * 2;
}

求这段代码的时间复杂度,首先设执行次数为x, 2^x=n 即 x=log2n，因此是对数阶O(log2n)

线性阶

1
2
3
4
5
6

int test(int n) {
    for(int i = 0; i<n; i++) {         // 需要执行 (n + 1) 次
        printf("Hello, World!\n");      // 需要执行 n 次
    }
    return 0;       // 需要执行 1 次
}

这段代码执行了(n+1+n+1)=2n+2次,运用计算方法去掉常数，化系数为1得到n，因此是线性阶O(n)。

线性对数阶

平方阶

1
2
3
4

int sum=0；                 
  for(i=1;i<=n;i++)        //需要执行n次
     for(j=1;j<=n;j++)   //需要执行n^2次
       sum++；

这段代码执行了n^2+n，运用计算方法去选取最高项，得到n^2，因此是平方阶O(n^2)。

立方阶

1
2
3
4
5
6
7
8

for(i=0;i<n;i++)
    {  
       for(j=0;j<i;j++)  
       {
          for(k=0;k<j;k++)
             x=x+2;  
       }
    }

这段代码执行了0+(1-1)*1/2+···+(n-1)n/2=n(n+1)(n-1)/6，运用计算方法去选取最高项，得到n^3，因此是平方阶O(n^3)。

指数阶

时间复杂度的最坏情况与平均情况

对于算法分析，一种是计算所有情况的平均值，这种时间复杂度的计算方法称为平均时间复杂度，它是最有意义的，因为是期望的运行时间。另一种是计算最坏情况下的时间复杂度，这种方法称为最坏时间复杂度。在一般情况下都是计算最坏时间复杂度。

空间复杂度

空间复杂度 是算法在运行时所占用的空间资源，程序在运行时产生临时变量需要占用存储空间，占用存储空间资源少算法效率高，占用存储空间资源多算法效率低。利用算法的空间复杂度，可以对算法的运行所需要的内存空间有个预先估计。

注：空间复杂度强调的是使用的辅助空间的大小，而不是指所有的数据所占用的空间大小。

空间复杂度的计算方法

1、若创建的变量为常数，则用O(1)表示。
2、若是递归算法，则空间复杂度=递归调用次数N*每次递归所要的辅助空间。

示例

1
2

int a,b,c;
printf("%d %d %d\n",a,b,c);

这段代码的存储3个变量，为常数，因此是O(1)。

1
2
3
4
5
6
7

int fun(int n){
int k=10;
if(n==k)
return n;
else
return fun(++n);
}

这段代码是递归算法，每次递归调用时都会创建1个变量，调用n次，空间复杂度O(n*1)=O(n)。

常用排序算法的时间复杂度和空间复杂度