软件设计师-数据结构篇

最近在复习数据结构的东西，以应对25号的软件设计师的考试；归纳和总结了一些自己的观点

 

数据结构的几个关键考点部分大体分为：

               1.对数据结构定理的基本了解(什么是数据结构，什么是算法，算法的特性和设计要求，算法的时间复杂度)

          2.顺序存储和链式存储之间的知识；栈，队列知识的理解；逆波兰式和中缀表达式的理解和转换

          3.树及二叉树的知识点（树的遍历，树与二叉树的区别，二叉树的基本性质，满二叉树，完全二叉树，二叉排序树，平衡二叉树，最优二叉树，M阶B-树，广义表） 

          4.矩阵的压缩存储（几种特殊的矩阵：对称矩阵，对角矩阵，上（下）三角矩阵，三对角矩阵）

          5.图（有向图，有向完全图，无向图，无向完全图，强联通图，强联通分量，图的存储结构，图的遍历，最小生成树，拓扑排序AOV与关键路径AOE）

          6.排序和查找（插入排序，选择排序，交换排序，归并排序，基数排序；顺序查找，二分查找，散列表）

 

          

 

一.基本认识

                              1.数据元素之间存在一种或多种特定关系的集合，而数据结构是研究数据逻辑结构和存储结构及其运算的实现，主要包括：集合，线性，树，图四种结构

                              2.算法的五个特性：

                                                   确定性：一个算法的每一条指令必须有确切的含义，不能产生二义性；相同的输入，只能产生相同相同的输出

                                                   有穷型：算法的执行步骤必须是在有穷步之后结束

                                                   可行性：算法能把问题真正解决

                                                   输入：一个算法有0个或多个输入

                                                  输出：一个算法有1个或多个输出

                             3.算法的设计要求：

                                                正确性：应当满足具体的问题要求

                                                可读性：能让人读懂，计算机可以运行

                                                健壮性：有容错处理能力，不容易被击垮

                                               高效率与低存储量：程序执行时间越小越好，占用计算机存储量越小越好

                             4.算法的时间复杂度：

                                             O（1）< O(log2n) < O(n) < O(nlog2n) < O(n^2) < O(n^3) <O(2^n) 

                                 注意： log2n   为log以2为底的n；  n^2   为n平方；n^3   为n的立方  ；2^n   为2的n次方

 

二 . 线性表

                          1. 数组，链表，栈，队列都是线性结构；

                          2.线性表的存储结构：

                             顺序存储：（常见代表：一般数组）

                                         优点：能随机存取和访问线性表中的任何节点

                                         缺点：大小通常是固定的，不利于元素的增加和删除，增加或者删除要移动其他元素

                             链接存储：(常见代表：链表)

                                         优点：大小不固定，元素的增加和删除不需要移动其他节点

                                         缺点：每个节点要加入一个猴急指针，话费更多的存储空间；不能随机的访问线性表中的节点

                        3.线性表的主要基本运算：

                                      （1） 链接存储只能顺序查找

                                      （2）插入运算：

                                            顺序存储：节点平均移动次数  n/2

                                            链接存储：直接将指针指向添加进来的节点

                                       （3）删除运算

                                           顺序存储： 节点平均 移动次数 （n+1）/2

                                           链接存储：    

                                                          a.链表为空，不执行删除

                                                          b.从头节点依次开始找，若找到要删除的节点，就移除，节点个数减1；若直到表尾都没有找到该节点，那么就不执行删除操作

                       4.栈：

                            (1)性质：先进后出

                            (2)栈的应用：数字转换，括号匹配，迷宫求解，行编辑程序，表达式求值

                            (3)逆波兰式与中缀表达式：

                               例子：a*（b+c)-d

                          逆波兰式：

                                       abc+*d-

                          中缀表达式：

                                       a*(b+c)-d

                        5.队列：

                           性质：先进先出

                           队空的判别条件：head=tail

                           队满的判别条件：（tail+1）%n = head

                           队长度：(tail-head+n)%n

三.树及二叉树的知识点

                       1.树的遍历：

                                  前序：根左右

                                  后序：左右根

                                  层次：自上而下，从左到右，逐层访问树的节点

                           树没有严格的左右之分，所以没有中序遍历之分

                        2.二叉树，节点的子树的是有序的，有左右两颗子树；树可能有多个子节点，没有严格的左右之分；

                           二叉树不是一颗特殊的树

                      3.树及森林转到二叉树

                          最左孩子节点为左孩子，兄弟节点变为右孩子

                      4.二叉树转树及森林

                          给各颗树一个总的父节点，然后按树及森林转二叉树一样的转

                      5二叉树的性质：

                           （1） 通用性质：

                                           性质一：  第i层上最多有2^（i-1）个节点

                                           性质二：  深度为K的二叉树最多有2^k - 1个节点

                                           性质三：  n0 = n2+1      （ 度为0 的节点 = 度为2的节点 + 1）

                                                           n = n0 + n1 + n2   （总的节点数 = 度为0的节点 + 度为1的节点  +  度为2的节点）

                             （2）满二叉树：

                                          深度为K，其有2^k - 1个节点的二叉树；直白点，就是其左右两个子节点都存在，不会出现度为1的节点。

                             （3）完全二叉树：

                                         实际为满二叉树的一部分；其节点数最多时，就是一颗满二叉树；

                                         满二叉树为完全二叉树，但是完全二叉树，不一定是满二叉树 ；

                                         完全二叉树度为1的节点只能是0或者1

                                        性质四：具有n个节点的完全二叉树，其深度为   |  log2 n  | + 1    (注意：log2  n   为下取整)

                                        性质五： 对一颗n的节点的完全二叉树节点节点层次编号，从第一层到 | log2 n | + 1 层，每层从做到右，对任意节点i有：

                                             ( a) 若i=1，那么该节点i没有双亲节点，是二叉树的根节点；若i>1,那么其双亲节点就是 |  i / 2 | 下取整

                                            （b）如果2i>n,那么节点i为叶子节点；无左孩子，否则其左孩子是2i；

                                            （c）2i + 1 > n ;那么节点i无有孩子，否则其有孩子是节点2i+1；

                           （4） 二叉树的遍历：

                                        前序：根左右

                                        中序：左根右

                                        后序：左右根

                                   以上三种属于深度优先遍历；

                                       

                                   层次：从上到下，从左到右；

                                   层次遍历属于广度优先遍历；

                                   以上所有遍历都采用递归遍历；

                          （5）二叉排序树（最优查找树，二叉查找树）：

                                   实际就是一颗 相当于根节点而言 左小右大 的树。

                                  内部路径长度：二叉排序树中，根节点到其他节点的路径长度；

                                  具有最小内部路径长度的称为  丰满树

                                  二叉查找树插入和删除的时间为 O（log2 n）

                          （6）平衡二叉树（AVL树）

                                   或者是一颗空树，或者是其左子树和右子树深度绝对值之差不操过1的树，且其左右子树各自都为平衡树。

                                   平衡二叉树的高度总为log2 n；

                                   基本操作的平均时间和最坏情况小的的时间都为：O(log2 n)          

                           （7）m阶B-树

                                  数中每个节点至少有m颗子树，

                                  除根节点和叶子节点之外，每个节点的孩子个数>= | m/2 | 上取整

                                  具有K个节点的非叶子节点还有k-1个键值

                                  所有叶节点在同一层，而且还不附有信息

                          （8）最优二叉树

                                   节点的带权路径长度 = 内部路径长度  *   该节点上的权值

                                   树的带权路劲长度 ： 树中所有叶子节点带权路劲之和

                                   最优二叉树（赫夫曼树）：具有最小的带权路劲长度的二叉树

                                  赫夫曼树是一颗严格的二叉树，没有度为1的节点

                                  赫夫曼树的构造

                         （9）二叉树的存储结构

                                  顺序存储

                                  链式存储

                         （10）广义表：

                                  LS = （a1，a2,a3,..........an）

                                   长度：表中原子和子表的个数

                                   深度：展开后所包含的括号的层数

                                   表头和表尾：第一个元素a1为表头；后面的其他元素都为表尾

                                  例：

                                   A = （） 空广义表，长度为0，深度为1

                                   B =（e） 长度为1，深度为1

                                   C = （a，（b,c,d）） 长度为2，深度为2

四.矩阵的压缩存储

                           1.对称矩阵：Aij = Aji （1<=i,j<=n）

                              

                                          1    -1      3

                                          -1    2      0

                                         3      0       1

                              

                           2.对角矩阵：

                                         a11     0      0     0

                                          0       a22  0     0

                                          0        0      a33  0  

                                          0        0      0       a44

                                            

                           3.上（下）三角矩阵

                                           a11    a12     a13     a14

                                           0        a22     a23     a24

                                           0           0      a33      a34

                                           0           0       0          a44

                                                （上三角矩阵）                             

 

                           4.单位矩阵（对角线全为1）

                                       1   0   0   0

                                        0  1   0    0

                                         0   0   1   0

                                         0    0   0   1

                           5.三对角矩阵

                                        1   1    0    0   0    0    0 

                                         1   1    1   0   0    0     0

                                          0   1    1   1   0   0     0

                                          0    0    1   1   1   0     0

                                          0    0    0    1   1   1    0

                                          0    0    0     0   1   1    1

                                          0    0    0     0   0    1    1

 

                         压缩存储的目的是为了节省存储空间。

 

五 .图

                        1.有向图：<>

                           有向完全图：任何两个顶点之间都有边，因为是有向的，所以两个顶点之间就会有两条边，一条是指出方向，

                          一条是指入方向；n个顶点的有向完全图至多有n*(n-1)条边   

                       2.无向图： （）

                           无向完全图：任何两个顶点之间都有边，不包括环的情况在内；n个顶点的完全无向图至多有   n*（n-1）/2 条边

                        3.连通图：

                           无向图中图中任意两个顶点都可以连通，即使不是直接连通，而是通过图中的其他节点或者其他路劲，他们能相互连通，这样的图就是连通图。

                        4.连通分量：

                           无向图中的极大连通子图

                        5.强连通分量：

                           有向图中，存在v1到v5的连通路劲，同时也存在v5到v1的连通路劲

                        6.强连通分量：

                          有向图中的极大强连通子图

                       7.图的存储：

                          邻接矩阵和邻接表

                       8.图的遍历：

                          深度优先遍历：类似于树的前序遍历

                          广度优先遍历：类似于层次遍历

                      10.最小生成树

                           普里姆算法：

                                    以点来考虑，适用于稠密图（边多点少的图）

                                   算法的时间复杂度为： O（n^2）

                           克鲁斯卡尔算法：

                                  以边来考虑，适用于稀疏图（边少点多的图）

                                  算法时间复杂度为： O（elog2  e）

                       11.最短路劲：

                            佛洛依德, 迪杰斯特拉(t贪心算法)

                            拓扑排序：

                                    AOV:没有权值的图

                                    AOE:有权值的图，可以求关键路劲，关键路径为各边权值相加后的最得值

六.排序和查找

                   1.排序的稳定性：两个值相等的数字，位置不同，一个在前，一个在后的位置，通过排序后，最开始在前的数值，被排到了在后的那个数值的后面，

                       这样的排序就    是不稳定的排序；

                   2.插入排序

                         直接插入排序：

                                                从未排序的序列中，依次取出一个元素与已排序的序列中的元素进行比较。稳定的排序

                         希尔排序：    

                                                 待排序列分成若干个子序列进行直接插入，待整个序列基本有序时，在对整体的的进行插入排序。不稳定的排序。

                                                 采用的是分治策略

                                                 D1 = | n/2 | 下取整 ，Di+1 =(Di/2) ；

                                                折半排序；

                    3.选择排序

                        直接选择排序：

                                   （a）若为升序排序，第一趟，选出数码最小的数，把它和第一个位置做交换；第二趟在以第二个数开始，

                                   选出数码最小的，并和第二个位置做交换。是不稳定的排序

                                     (b) 第一趟排序下来，一定是最小的数或者最大的关键字。

                                    不稳定的排序

                        堆排序：先把序列构成一颗完全二叉树，完全二叉树中最后一个非终端节点（非叶子节点）开始排序，在根据大顶堆，小顶堆的定义来排序

                                    大顶堆：

                                            根节点比其左，右两子树节点都大

                                    小顶堆：

                                            根节点比其左，右两子树节点都小；

                                     排序完后把根节点和最后一个叶子节点交换，输出该叶子节点。

                                   不稳定的排序

                    4.交换排序:

                         冒泡排序：

                                      最后一个数第一趟排序下来不是最小的，就是最大的关键字。

                                      稳定的排序。

                         快速排序：

                                      采用分治的策略

                                      不稳定的排序

                    5.归并排序

                           对m个元素进行K路归并，归并的趟数为：s=|  logk m |上取整。

                           稳定的排序

                    6.链式基数排序：

                     

                      任何一个借助比较进行的算法，在最坏情况下所需要进行的比较次数至少为 log2（n!）

                     

排序总结类别排序方法平均情况最好情况最坏情况辅助存储稳定性插入排序直接插入排序O(n^2)O(n)O(n^2)O(1)稳定插入排序希尔排序O(n^1.3)O（n）O（n^2）O(1)不稳定选择排序直接选择排序O(n^2)O（n^2）O(n^2)O(1)不稳定选择排序堆排序O(nlog2 n)O(nlog2 n)O（nlog2 n）O(1)不稳定交换排序冒泡排序O(n^2)O（n）O（n^2）O(1)稳定交换排序快速排序O(nlog2 n)O（nlog2 n）O（n^2）O(nlog2 n)不稳定归并排序归并排序O(nlog2 n)O(nlog2 n)O(nlog2 n)O(n)稳定链式基数排序链式基数排序O(d(n+rd))O(d(n+rd))O(d(n+rd))O(rd)稳定

                     

 

 

 

                    7.查找

                        顺序查找：

                                       平均查找长度（n+1）/2;

                        二分查找：

                                  条件：

                                        是一个有序序列；只适合顺序存储的结构。

                                   二分查找成功平均的

                                                         查找长度为：log2 （n+1） - 1

                                                         最坏比较次数：log2 （n+1）

                                                         时间复杂度为：O（log2 n）

                       分块查找

 

                        散列表：