软考重点6 数据结构与算法

Posted 2022-11-27 编程圈子

软考重点6：数据结构与算法

• 一、数据结构和算法
• • 1. 逻辑结构
  • • （1）线性结构
    • （2）非线性结构
  • 2. 存储结构
  • 3. 顺序表
  • 4. 链表
• 二、数组和字符串
• 三、矩阵
• • 1. 特殊矩阵
  • 2. 非特殊矩阵
  • 3. 矩阵乘法
• 三、栈和队列
• • 1. 队列（先进先出，FIFO——first in first out)
  • 2. 栈（先进后出，FILO——first in last out）
• 四、树
• • 1. 树的基本概念
  • 2. 二叉树
  • • （1）一些概念
    • • 满二叉树
      • 完全二叉树
      • 非完全二叉树
    • （2）二叉树的特性
  • 3. 树的遍历
  • 4. 特殊二叉树
  • • （1） 二叉排序树
    • （2） 哈夫曼树
• 五、图
• • 1. 图的分类
  • • （1）有向图
    • （2）无向图
    • （3）连通图
    • （4）完全图
  • 2. 图的转换：无向图转邻接矩阵
  • • 无向图转换的邻接矩阵为对称矩阵。
    • 有向图转邻接矩阵
  • 3. 度
  • • （1）入度
    • （2）出度
  • 4. 有向图转邻接链表
• 六、算法特性与复杂度
• • 1. 算法的特性
  • 2. 算法评价指标
  • 3. 时间复杂度
  • 4. 空间复杂度
• 七、查找
• • 1. 顺序查找
  • 2. 二分查找（折半查找）
  • • （1）二分法查找循环算法
    • （2）二分法排序递归算法
  • 3. 散列表查找：
  • • （1）线性探查法
    • （2）拉链法
• 八、排序
• • 1. 基本概念
  • 2. 插入类排序
  • • （1） 直接插入排序
    • （2）希尔排序
  • 3. 交换类排序
  • • （1）冒泡排序
    • （2）快速排序
  • 4. 选择类排序
  • • （1）直接选择排序
    • （2） 堆排序
  • 5. 归并排序
  • 6. 基数排序
  • 7. 总结

一、数据结构和算法

数据结构：元素之间的关系，分为逻辑结构和存储结构。

1. 逻辑结构

（1）线性结构

每个元素前、后最多都只能有一个节点，如：线性表、栈、队列、数组、串

（2）非线性结构

如：二维数组、多维数组、树、图等

2. 存储结构

• 顺序存储
• 链接存储

3. 顺序表

含有n个元素的线性表采用顺序存储，等概率删除其中任一个元素，平均需要移动$$\frac{n-1}{2}$$个元素。

4. 链表

链表中的每个元素称为结点，每个结束是一个结构体变量，分为：

• 数据部分

• 指针变量：通常具有指向自身结构体类型的指针变量，存放下一结点的地址，最后一个结点的地址为NULL（单链表）。

• 尾结束：最后一个结点

• 尾指针：找尾结点的指针

• 头结点：第一个结点

• 头指针：指向头结点的指针变量

• 首结点：第一个有效结点

• 循环链表，尾指针指向头结点地址。

• 双向链表：每个结点增加一个front用来存放前一个结点地址。

二、数组和字符串

数组：表示n个数据类型相同的元素所组成的序列。
字符串：字符构成的一维数组。

• 空串： 没有任何字符
• 空白串：字符都是不可见的
• 子串：串中任意个连续的字符组成的子序列
• 非平凡子串：非空且不同于字符串本身
• 串的模式匹配：模式串在主串中首次出现的位置
• 字符串的比较：从左到右按ASCIID码值进行比较

三、矩阵

1. 特殊矩阵

• 三角矩阵：上三角矩阵、下三角矩阵（存非零元素即可）。
• 对角矩阵
• 对称矩阵：$A_{ij}=A_{ji}$
• 反对称矩阵：$A_{ij}=-A_{ji}$

2. 非特殊矩阵

• 稀疏矩阵：使用三元组存储

3. 矩阵乘法

三、栈和队列

1. 队列（先进先出，FIFO——first in first out)

• 队尾： rear
• 队头：front

2. 栈（先进后出，FILO——first in last out）

四、树

1. 树的基本概念

• 父结点
• 子结点
• 兄弟结点
• 叶子结点：没有子结点
• 结点的度：结点有几个子结点
• 树的度：所有结点度最大的值
• 二叉树：树的度不超过2
• 层（深度、高度）

2. 二叉树

（1）一些概念

满二叉树

每一层都不能增加结点

完全二叉树

除了最后一层，都不能增加结点。 最后一层左侧连续有，右侧连续无。

非完全二叉树

除了最后一层，都不能增加结点。但不满足最后一层左侧连续有、右侧连续无的条件 。

（2）二叉树的特性

• 每一层上最多有$2^{n-1}$个节点
• 深度为k的二叉树最多有$2_k-1$个节点
• 如果对一棵有n个结点的完全二叉树的结点按层序编号，有：

如果i=1，则结点i无父结点，二叉树的根；如果i>1，则父结点是 i/2取整。
如果2i>n，则结点i为叶子结点，无左子结点；否则，其左子结点是结点2i。
如果2i+1>n，则结点i无右子结点，否则，其右子结点是结点2i+1。

3. 树的遍历

• 前序/先序遍历
• 中序遍历
• 后序遍历
• 层序遍历

4. 特殊二叉树

（1） 二叉排序树

• 二叉排序/查找树
• 左子树小于根
• 右子树大于根

值最小的结点无左子树
值最大的结点无右子树。
二叉查找树的中序遍历序列为从小到大排列的序列
每一层从左到右进行遍历的序列为从小到大排列的序列。

（2） 哈夫曼树

• 树的路径长度：从树根到树中每一结点的长度之路
• 权：在一些应用中，赋予树中结点的一个有特定含义的数
• 带权路径长度：结点到树根之间的路径长度与该结点上权的乘积
• 树的代价：树的带权路径长度
• 哈夫曼树的构造

五、图

1. 图的分类

（1）有向图

一个顶点到另一个顶点是有方向的；

（2）无向图

（3）连通图

任意两个顶点之间都有一个路径相连。

• 强连通：有方向的情况下都连通
• 弱连通：不考虑方向的连通

（4）完全图

• 在无向图中，若每对顶点之间都有一条边相连，则为完全图。
• 在有向图中，若每对顶点之间都有两条有向连互连，则为完全图。

n个顶点的无向图和有向图的完全图边的个数计算：

• 无向图：$\frac{n\ast (n-1)}{2}$
• 有向图： $n\ast (n-1)$

2. 图的转换：无向图转邻接矩阵

用一个n阶的方阵R来存放图中各结点的关联信息。

无向图转换的邻接矩阵为对称矩阵。

有向图转邻接矩阵

无穷大表示无连接。

3. 度

（1）入度

指向该结点的边的数量

（2）出度

从该结点指出去的边的数量。

4. 有向图转邻接链表

六、算法特性与复杂度

1. 算法的特性

• 有穷性
• 确定性

2. 算法评价指标

• 正确性
• 友好性
• 可读性
• 健壮性
• 效率

3. 时间复杂度

常见的算法时间复杂度：
$$O(1)<(lo{g}_{2}n)<O(n)<O(nlo{g}_{2}n)<O(n^2)<O(n^3)<O(2^n)$$

• 二分查找： $lo{g}_{2}n$
• 一次循环： O(n)
• 插入、冒泡、选择排序：$O(n^2)$

4. 空间复杂度

临时空间占用大小。

七、查找

1. 顺序查找

从头到尾依次查找。
平均查找长度： $\frac{n+1}{2}$

2. 二分查找（折半查找）

• 前提：有序表、顺序表。
• 折半出现小数时向下取整。
• 折半查找的时间复杂度为$O(lo{g}_{2}n)$
• 折半查找成功时关键字的比较次数最多为$lo{g}_{2}n+1$次。

（1）二分法查找循环算法

int biSearch(int r[], int low, int high, int key)
    int mid;
    while(low<=high )
        mid = (low+high)/2;
        if(key == r[mid]) return mid;
        else if(key<r[mid]) high = mid-1;
        else low = mid+1;
    
    return -1;

int main()
    int data[] = 1,2,3,4,5;
    int low=0;
    int high=sizeof(data) /sizeof(int);
    int key=3;
    int find = biSearch(data, low, high, key);
    printf("result: %d", find);

（2）二分法排序递归算法

int biSearchRecursion(const int r[], int low, int high, int key)
    int mid;
    if(low<=high)
        mid = (low + high) /2;
        if(key ==r[mid]) return mid;
        else if(key<r[mid]) return biSearchRecursion(r, low, mid-1, key);
        else return biSearchRecursion(r, mid+1, high, key);
    
    return -1;

int main()
    const int data[] = 1,2,3,4,5;
    int low=0;
    int high=sizeof(data) /sizeof(int);
    int key=3;
    int find = biSearchRecursion(data, low, high, key);
    printf("result: %d", find);
    return 0;

3. 散列表查找：

（1）线性探查法

• 示例散列函数： $h=key$
• 冲突解决：放在后面最近的空格里

（2）拉链法

仍使用散列函数，用链地址法。按关键码构造链，链的数量与关键码一致。

八、排序

1. 基本概念

• 稳定排序：相同值排序后保持前后序号
• 不稳定排序：相同值排序后序号不保持原来顺序

2. 插入类排序

（1） 直接插入排序

插入的元素与现有元素挨个比较，每次从元素前面一个元素比较，比前一元素小的话就继续往前比较。
直接插入排序在元素基本有序时比较有优势。

代码示例:

void insertSort(int data[], int n)
    int i,j;
    int tmp;
    for(i=1;i<n;i++)
        if(data[i]<data[i-1])
            tmp = data[i];
            data[i] = data[i-1];
            // 元素往后移
            for(j=i-2;j>=0 && data[j]>tmp;j--)
                data[j+1]=data[j];
            
            data[j+1]=tmp;
        
    


int main()
    int data[] = 3,4,5,3,5,1,22;
    insertSort(data, 7);
    for(int i=0;i<7;i++)
        printf("%d=%d\\n", i, data[i]);
    
    return 0;

（2）希尔排序

不稳定排序

3. 交换类排序

（1）冒泡排序

相邻元素比较和交换，一趟排序后最大移到最右、或最小移到最左。

示例代码：

#include <stdio.h>
int less(int x,int y)
    return ((x<y)?1:0);

int large(int x, int y)
    return ((x>y)?1:0);


void bubbleSort(int arr[], int n, int(*compare)(int,int))
    int i,j;
    int swapped =1;
    for(i=0;swapped;i++)
        swapped=0;
        for(j=0;j<n-1;j++)
            if(compare(arr[j+1],arr[j]))
                swap(arr[j+1], arr[j]);
                swapped = 1;
            
        
    


void bubbleSortTest()
    int data1[] = 4,2,6,3,1;
    bubbleSort(data1, 5, less);
    for(int i : data1)
        printf("%d ", i);
    

int main() 
	bubbleSortTest();
    return 0;

（2）快速排序

代码：

int qusort(int s[],int start,int end)    //自定义函数 qusort()

    int i,j;    //定义变量为基本整型
    i=start;
以上是关于软考重点6 数据结构与算法的主要内容，如果未能解决你的问题，请参考以下文章
 
 初级程序员软考重点6 数据结构与算法
 数据结构与算法-----快速排序
 简练软考知识点整理-控制成本过程
 软考重点5 程序设计语言
 软考重点1 计算机内数据表示及编码基础
 软考重点1 计算机内数据表示及编码基础