【数据结构复习】部分知识提纲/总结

7.2 图的存储结构

7.4 图的连通性问题

最小生成树

1. 生成树条件：
   1. 全部顶点
   2. 部分边
   3. 无回路
2. 最小生成树：权最小的生成树
3. 点：prim
   1. 任取一个点，进入解集
   2. 对解集画圈，找与圈连接的最小边，将那个边另一侧的点放入解集
   3. 重复步骤2，直到所有点被圈住
4. 边：krukal
   1. 将边按权值排序，列出权值表
   2. 从权值表中拿出权值最小的边（要判断此时是否形成回路，若有回路，则放回，重新选择除了这条边之外的最小边）
   3. 直到选了n-1条边（包含了所有结点，且无回路）
      1. 避免回路：标号法 
         1. 列一个表，含有顶点名和顶点标号
         2. 每选一条边，就把小顶点标号的值赋给大的顶点标号
         3. 若选边时发现两顶点标号相同，则不选
         4. 最终所有标号都为同一数值

7.5 拓扑排序

1. 路径
   1. 找不被指向的点，随便选一个，从图中删除，放入队列
   2. 若图中还有结点，返回第一步
2. 关键路径
   1. 贪心
   2. 一步一步走，取最大（小）权值

10.1 排序概述

分类

1. 内部排序：将待排序的元素放入内存中，进行排序
2. 外部排序：数据量大，无法一次将所有数据放入内存。排序时需要访问外存

主要讲内部排序，内部排序分类

按工作量分类

1. 简单排序：O(n^2)
2. 先进排序：O(nlogn)
3. 基数排序：O(d*n)

约定之后的待排序记录都存储在一片连续的空间上，下标为0的空间作为哨兵或不用

10.2 插入排序

10.2.1 直接插入排序（Straight Insertion Sort）

流程

1. 将第1个数插入数组
2. 将第2个数插入该具有1个元素的有序数组
3. 将第3个数插入该具有2个元素的有序数组
4. .。。。。。。。
   1. 假设是从小到大，则只需从末尾开始，比较插入的数与数组中的数字，直到要插入的数字>=数组中的数，则将数字插入到'该'位置
   2. 注意其他元素要后移。最后插入的位置是否+1

代码:

插入排序，三种写法

/*
  插入排序
  数组从下标1开始存储元素
 */
#include <stdio.h>
#define MAXSIZE 20//一个作为示例的小顺序表的最大长度
typedef struct
{
    int r[MAXSIZE + 1];//存储数据的数组
    int length;//数组当前长度
} SqList;
void list_insert(SqList &L, int e)
{
    //将元素e插入表L
    L.r[++L.length] = e;
}
void list_print(SqList L)
{
    //输出表中内容
    for (int i = 1; i <= L.length; i++)
    {
        printf("%d ", L.r[i]);
    }
    printf("\n");
}
void InsertSort_0(SqList &L)
{
    //书上写法
    //对顺序表L直接插入排序，书上写法
    for (int i = 2; i <= L.length; ++i)
    {
        if (L.r[i] < L.r[i - 1]) //'<'
        {
            L.r[0] = L.r[i]; //哨兵
            L.r[i] = L.r[i - 1]; //判断一次，交换一次
            int j;
            for (j = i - 2; L.r[0] < L.r[j]; --j)
            {
                L.r[j + 1] = L.r[j];
            }
            L.r[j + 1] = L.r[0];
        }
    }
}
void InsertSort_1(SqList &L)
{
    //自己瞎写
    //对顺序表L直接插入排序，无哨兵
    for (int i = 2; i <= L.length; i++)
    {
        int val = L.r[i]; //要插入的元素
        int j = i;
        while (j > 1 && val < L.r[j - 1])
        {
            L.r[j] = L.r[j - 1];
            j--;
        }
        L.r[j] = val;
    }
}
void InsertSort_2(SqList &L)
{
    //王道写法
    //对顺序表L直接插入排序，无哨兵
    for (int i = 2; i <= L.length; i++)
    {
        int val = L.r[i]; //要插入的数
        int j;
        for (j = i - 1; j >= 1 ; j--)
        {
            if (val < L.r[j])
            {
                L.r[j + 1] = L.r[j];
            }
            else
                break;
        }
        L.r[j+1]=val;
    }
}
void test0()
{
    SqList L;
    L.length = 0;
    for (int i = 1; i <= 10; i++)
        list_insert(L, 11 - i);
    list_print(L);
    //以上是表初始化,以下是排序，输出
    InsertSort_0(L);
    list_print(L);
}
void test1()
{
    SqList L;
    L.length = 0;
    for (int i = 1; i <= 10; i++)
        list_insert(L, 11 - i);
    list_print(L);
    //以上是表初始化,以下是排序，输出
    InsertSort_1(L);
    list_print(L);
}
void test2()
{
    SqList L;
    L.length = 0;
    for (int i = 1; i <= 10; i++)
        list_insert(L, 11 - i);
    list_print(L);
    //以上是表初始化,以下是排序，输出
    InsertSort_2(L);
    list_print(L);
}
int main()
{
    test0();
    test1();
    test2();
    return 0;
}

 

10.3 快速排序

1. 以第一个元素为基准，将数组分成两半，把基准放中间
2. 对两半进行同样操作，递归（结束条件：数组长度<=1）