数据结构--图（更新ing~）

已于 2023-12-28 12:33:14 修改
阅读量547 收藏 8
点赞数 9
文章标签： 数据结构
于 2023-12-18 23:49:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NNLYF_/article/details/134793551
版权

  树具有灵活性，并且存在许多不同的树的应用，但是就树本身而言有一定的局限性，树只能表示层次关系，比如父子关系。而其他的比如兄弟关系只能够间接表示。

推广---  图

图形结构中，数据元素之间的关系是任意的。

一、图的基本概念

二、图的分类

三、图的相关术语

1、顶点的度

无向图：n个顶点找两条，没有方向，

2、路径和路径长度

3.子图

4.图的连通

1）无向图的连通

2）有向图的连通

5.生成树

#不讨论的图：

四、图的存储方法

1、邻接矩阵存储方法

对称矩阵：

一个对称矩阵是指矩阵的主对角线两侧的元素相等。在这个矩阵中，通过观察可以发现对称性质：矩阵的第i行第j列的元素等于第j行第i列的元素。

无向图的邻接矩阵一定是对称的。

有向图的邻接矩阵一定是不对称的。

  有向图中每个节点之间的边是有方向的，因此如果节点i到节点j有一条有向边，那么邻接矩阵中第i行第j列的元素就为1或者权值，而第j行第i列的元素为0（无权值的情况）或者无穷（有权值的情况）。

**无向图的邻接矩阵建图和度数输出（完整代码）

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#define N (100 + 5)
#define INF 0x3f3f3f3f//定义INF为一个十六进制无穷大常量

typedef char VexType; //顶点为字符类型
typedef int EdgeType;//邻接矩阵类型为整型

typedef struct {
    int n, m; //n个顶点，m条边
    VexType vex[N];//一维数组存放所有顶点的数据信息
    EdgeType edge[N][N];//邻接矩阵(二维数组存放图中所有顶点之间关系的信息)
} adjGraph;

//1.邻接矩阵建图
adjGraph createGraph();
//2.输出图的信息（顶点、邻接矩阵）
void print(adjGraph g);
//3.输出图中每个顶点的度数
void printDegree(adjGraph g);

int main()
{
    //1.建图
    adjGraph g = createGraph();
    //2.输出图的信息
    print(g);
    printDegree(g);
    return 0;
}

adjGraph createGraph()//建图
{
    adjGraph g;
    memset(g.edge, 0, sizeof(g.edge));//内存设置函数--创建图的过程中，所有元素初始化为0
    // g.edge 邻接矩阵
    //sizeof(g.edge) 数组占用的总字节数
    scanf("%d%d", &g.n, &g.m);//输入顶点数和边数
    getchar();//吸收换行符
    //1.输入n个顶点
    for (int i = 0; i < g.n; i++) {
        scanf("%c ", &g.vex[i]);
    }
    //2.输入m条边，按照邻接矩阵存图
    for (int i = 0; i < g.m; i++) {
        char v1, v2;
        scanf("\n%c %c", &v1, &v2);//读入当前边的2个顶点
        int n1 = v1 - 'A', n2 = v2 - 'A';
         //将顶点字符转换为对应的数组索引。
        // 假设顶点标签是大写字母'A'、'B'、'C'等，通过将其减去字符'A'的ASCII码值
        // 可以得到对应的数组索引（0、1、2等）。   
        g.edge[n1][n2] = g.edge[n2][n1] = 1;
        //无向图，邻接矩阵对应的n1行n2列和n2n1列都赋值为1(邻接矩阵的对称性）
        //将对应的邻接矩阵元素设置为1，表示图中对应的顶点之间存在一条边。
    }

    return g;
}

void print(adjGraph g)
{
    printf("图有%d个顶点，%d条边\n", g.n, g.m);
    printf("图的顶点是：");
    for (int i = 0; i < g.n; i++) {
        printf("%c ", g.vex[i]);
    }
    printf("\n图的邻接矩阵是：\n");
    for (int i = 0; i < g.n; i++) {
        for (int j = 0; j < g.n; j++) {
            printf("%4d", g.edge[i][j]);
        }
        printf("\n");
    }
}

void printDegree(adjGraph g)
{
    printf("图中每个顶点的度数是：");
    for (int i = 0; i < g.n; i++) {
        int degree = 0;
        for (int j = 0; j < g.n; j++) {
            if (g.edge[i][j] == 1) {
                degree++;
            }
        }
        printf("%c: %d ", g.vex[i], degree);
    }
    printf("\n");
}

输入样例：

**有向图邻接矩阵建图和度数输出（附完整代码）

修改的部分：

  • 将g.edge[n1][n2] = g.edge[n2][n1] = 1; 修改为 g.edge[n1][n2] = 1; 表示从顶点n1指向顶点n2的有向边。
  • 把无向图中的度数输出改成入度和出度输出
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#define N (100 + 5)
#define INF 0x3f3f3f3f//定义INF为一个十六进制无穷大常量

typedef char VexType; //顶点为字符类型
typedef int EdgeType;//邻接矩阵类型为整型

typedef struct {
    int n, m; //n个顶点，m条边
    VexType vex[N];//一维数组存放所有顶点的数据信息
    EdgeType edge[N][N];//邻接矩阵(二维数组存放图中所有顶点之间关系的信息)
} adjGraph;

//1.邻接矩阵建图
adjGraph createGraph();
//2.输出图的信息（顶点、邻接矩阵）
void print(adjGraph g);
//3.输出图中每个顶点的度数
void printDegree(adjGraph g);

int main()
{
    //1.建图
    adjGraph g = createGraph();
    //2.输出图的信息
    print(g);
    printDegree(g);
    return 0;
}

adjGraph createGraph()//建图
{
    adjGraph g;
    memset(g.edge, 0, sizeof(g.edge));//内存设置函数--创建图的过程中，所有元素初始化为0
    // g.edge 邻接矩阵
    //sizeof(g.edge) 数组占用的总字节数
    scanf("%d%d", &g.n, &g.m);//输入顶点数和边数
    getchar();//吸收换行符
    //1.输入n个顶点
    for (int i = 0; i < g.n; i++) {
        scanf("%c ", &g.vex[i]);
    }
    //2.输入m条边，按照邻接矩阵存图
    for (int i = 0; i < g.m; i++) {
        char v1, v2;
        scanf("\n%c %c", &v1, &v2);//读入当前边的2个顶点
        int n1 = v1 - 'A', n2 = v2 - 'A';
        //将顶点字符转换为对应的数组索引。
       // 假设顶点标签是大写字母'A'、'B'、'C'等，通过将其减去字符'A'的ASCII码值
       // 可以得到对应的数组索引（0、1、2等）。   
        g.edge[n1][n2] = 1;
        //有向图，邻接矩阵对应的n1行n2列赋值为1
        //将对应的邻接矩阵元素设置为1，表示图中对应的顶点之间存在一条边。
    }

    return g;
}

void print(adjGraph g)
{
    printf("图有%d个顶点，%d条边\n", g.n, g.m);
    printf("图的顶点是：");
    for (int i = 0; i < g.n; i++) {
        printf("%c ", g.vex[i]);
    }
    printf("\n图的邻接矩阵是：\n");
    for (int i = 0; i < g.n; i++) {
        for (int j = 0; j < g.n; j++) {
            printf("%4d", g.edge[i][j]);
        }
        printf("\n");
    }
}

void printDegree(adjGraph g)
{
    printf("图中每个顶点的入度是：\n");
    for (int i = 0; i < g.n; i++) {
        int indegree = 0;
            for (int j = 0; j < g.n; j++) {
                if (g.edge[j][i] == 1) {
                    indegree++;
                 }
            }
            printf("%c: %d \n", g.vex[i], indegree);
       }
       
  


    printf("图中每个顶点的出度是：\n");
    for (int i = 0; i < g.n; i++) {
        int outdegree = 0;
        for (int j = 0; j < g.n; j++) {
            if (g.edge[i][j] == 1) {
                outdegree++;
            }
        }
        printf("%c: %d \n", g.vex[i], outdegree);
        
    }

}

测试样例：

**有向带权图邻接矩阵建图和度数输出（含完整代码）

要注意有向图带权图中，含有权值的线路如 A 20 B ，反过来B到A就是 INF，不相连的两个顶点之间也是INF

**自环考虑为0的情况 **  实际情况和做题中通常考虑为无穷大

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#define N (100 + 5)
#define INF 0x3f3f3f3f//定义INF为一个十六进制无穷大常量

typedef char VexType; //顶点为字符类型
typedef int EdgeType;//邻接矩阵类型为整型

typedef struct {
    int n, m; //n个顶点，m条边
    VexType vex[N];//一维数组存放所有顶点的数据信息
    EdgeType edge[N][N];//邻接矩阵(二维数组存放图中所有顶点之间关系的信息)
} adjGraph;

//1.邻接矩阵建图
adjGraph createGraph();
//2.输出图的信息（顶点、邻接矩阵）
void print(adjGraph g);
//3.输出图中每个顶点的度数
void printDegree(adjGraph g);

int main()
{
    //1.建图
    adjGraph g = createGraph();
    //2.输出图的信息
    print(g);
    printDegree(g);
    return 0;
}


adjGraph createGraph()//建图
{
    adjGraph g;
    memset(g.edge, 0, sizeof(g.edge));//内存设置函数--创建图的过程中，所有元素初始化为0
    // g.edge 邻接矩阵
    //sizeof(g.edge) 数组占用的总字节数
    scanf("%d%d", &g.n, &g.m);//输入顶点数和边数
    getchar();//吸收换行符
    //1.输入n个顶点
    for (int i = 0; i < g.n; i++) {
        scanf("%c ", &g.vex[i]);
    }
    //2.输入m条边，按照邻接矩阵存图 
    // 将邻接矩阵初始化为INF
    for (int i = 0; i < g.m; i++) {
        for (int j = 0; j < g.m; j++) {
            g.edge[i][j] = INF;
        }
    }
    for (int i = 0; i < g.m; i++) {
        char v1, v2;
        int weight;
        scanf("\n%c %d %c", &v1, &weight, &v2);//读入当前边的2个顶点
        int n1 = v1 - 'A', n2 = v2 - 'A';
        //将顶点字符转换为对应的数组索引。
        // 假设顶点标签是大写字母'A'、'B'、'C'等，通过将其减去字符'A'的ASCII码值
        // 可以得到对应的数组索引（0、1、2等）。
       
        if (n1 == n2) {
            g.edge[n1][n2] = 0;
        }
        else {
            g.edge[n1][n2] = weight;
            g.edge[n2][n1] = INF; // 反方向的边权值设置为INF
        }
    }


    return g;
}

void print(adjGraph g)
{
    printf("图有%d个顶点，%d条边\n", g.n, g.m);
    printf("图的顶点是：");
    for (int i = 0; i < g.n; i++) {
        printf("%c ", g.vex[i]);
    }
    printf("\n图的邻接矩阵是：\n");
    for (int i = 0; i < g.n; i++) {
        for (int j = 0; j < g.n; j++) {
            if (i == j) printf("0 ");
            else if (g.edge[i][j] == INF)
            {
                printf("INF ");
           }
            else  {
                   printf("%-4d", g.edge[i][j]);
            }
                  
        
            
        }
        printf("\n");
    }
}

void printDegree(adjGraph g)
{
    printf("图中每个顶点的入度是：\n");
    for (int i = 0; i < g.n; i++) {
        int indegree = 0;
        for (int j = 0; j < g.n; j++) {
     
                  if (g.edge[j][i] != 0 && g.edge[j][i] != INF) {
                     indegree++;
                 }
    
            
        }
        printf("%c: %d \n", g.vex[i], indegree);
    }




    printf("图中每个顶点的出度是：\n");
    for (int i = 0; i < g.n; i++) {
        int outdegree = 0;
        for (int j = 0; j < g.n; j++) {
                if (g.edge[i][j] != 0&& g.edge[i][j] != INF) {
                    outdegree++;
                }
            }

        
        printf("%c: %d \n", g.vex[i], outdegree);

    }

}

样例：

2、邻接表存储方法

  对每一个顶点建立一个单链表，将同一个顶点发出的边链接在一个称为边链表的单链表中。

头插法：

无向图中相连即放在链表里作为边结点（包含与该点相连的所有顶点）。

有向图按照方向选择结点作为边结点。‘’

** 邻接表计算顶点的度 函数

无向图：

void printDegree(adjListGraph graph) //无向图
{
    //计算每个顶点的度数
    for (int i = 0; i < graph.n; i++) {//遍历每个顶点
        int Degree = 0;

        //计算入度
        for (int j = 0; j < graph.n; j++) { //遍历所有顶点，寻找与当前顶点相关的边
            ELink* p = graph.vex[j].edge;//获取第KJj个顶点的邻接表
            while (p) {//遍历该邻接表中的所有边
                if (p->adjvex == i) {//如果当前边指向当前顶点
                    Degree++;
                    break;//跳出循环，继续计算下一个顶点的入度
                }
                p = p->next;//否则继续遍历该邻接表中的下一条边
            }
        }
  
        printf("顶点%c的度为%d\n", graph.vex[i].vertex, Degree);
    }
}

有向图：

void printDegree(adjListGraph graph) //有向图
{
    //计算每个顶点的度数
    for (int i = 0; i < graph.n; i++) {//遍历每个顶点
        int inDegree = 0;
        int outDegree = 0;
        //计算入度
        for (int j = 0; j < graph.n; j++) { //遍历所有顶点，寻找与当前顶点相关的边
            ELink* p = graph.vex[j].edge;//获取第j个顶点的邻接表
            while (p) {//遍历该邻接表中的所有边
                if (p->adjvex == i) {//如果当前边指向当前顶点
                    inDegree++;
                    break;//跳出循环，继续计算下一个顶点的入度
                }
                p = p->next;//否则继续遍历该邻接表中的下一条边
            }
        }
        ELink* p = graph.vex[i].edge;//获取当前顶点的邻接表
        while (p) {//遍历该邻接表中的所有边
            outDegree++;//记录当前顶点的出度
            p = p->next;//继续遍历该邻接表中的下一条边
        }
        printf("顶点%c的入度为%d，出度为%d\n", graph.vex[i].vertex, inDegree, outDegree);
    }
}

五、图的遍历

1.深度优先遍历

** 访问完顶点v以后访问的是v的邻接点，比如ABCD，访问了B，那下一步走A或者C都是可以的。

2.广度优先遍历

**无向图的创建、度的计算、dfs和bfs（完整代码）

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define N (100+5)
#define INF (0x3f3f3f3f) //定义INF为一个十六进制无穷大常量
typedef char vexType;//顶点类型
int visited[N];//状态数组，标记当前点有没有被访问过

//邻接边
typedef struct edge {
    int adjvex;//邻接点的下标，从0开始
    int weight;//边的权重
    struct edge* next;//下一个邻接点的地址
}ELink;


//邻接点
typedef struct {
    vexType vertex;//顶点的数据
    ELink* edge;//指向第一条依附于该顶点的边的指针
}VLink;

typedef struct {
    int n, m;//n个顶点，m条边
    VLink vex[N];//邻接点数组
}adjListGraph;
//1.邻接表建图
void createGraph(adjListGraph* graph);
//2.打印图
void printGraph(adjListGraph graph);
//3.输出图的度数（入度、出度、度数）
void printDegree(adjListGraph graph);
//4.1 深度优先遍历-从下标为n的点出发
void dfs(adjListGraph graph, int n);
//4.2 深度优先遍历-搜所有的点
void dfsAll(adjListGraph graph);
//5.1 广度优先遍历-从下标为n的点出发
void bfs(adjListGraph graph, int n);
//5.2广度优先遍历--搜所有的点
void bfsAll(adjListGraph graph);

//循环队列
#define M (1000+5)
typedef int ElemType;//队列元素类型
typedef struct {
    ElemType data[M];
    int front, rear;
}SqCyQueue;
//0.初始化队列
void init(SqCyQueue* q);
//1.队列是否为空，空则返回1，否则返回0
int isEmpty(SqCyQueue q);
//2.队列是否已满，满了返回1，否则返回0
int isFull(SqCyQueue q);
//入队 成功返回1，否则返回0
int push(SqCyQueue* q, ElemType item);
//出队 成功返回1，否则返回0
int pop(SqCyQueue* q, ElemType* item);

int main()
{
    memset(visited, 0, sizeof(visited));//visited 数组中的所有元素都赋值为 0，从而实现对数组的初始化
    adjListGraph g;
    createGraph(&g);
    printGraph(g);
    printDegree(g);
    int n = 0;//n不同就是从第n+1个点开始dfs或者bfs
   
    printf("\n从%c点出发深度优先遍历\n", g.vex[n].vertex);
    //从第一个点开始深度搜索
    dfs(g, n);
     printf("\n深度搜索所有点\n");
    dfsAll(g);
    
    printf("\n从%c点出发广度优先遍历\n", g.vex[n].vertex);
    bfs(g, n);
    printf("\n广度搜索所有点\n");
    bfsAll(g);
    return 0;
}

1.邻接表建图
(一）无向图
void createGraph(adjListGraph* graph)
{
    //1.输入n个顶点和m条边
    scanf("%d%d", &graph->n, &graph->m);

    //2.输入n个顶点，存入图邻接点数组中
    for (int i = 0; i < graph->n; i++) {
        //读入的字符数据是不是有效的
        while (1) {
            char c = getchar();
            if (c >= 'A' && c <= 'Z' || c >= '0' && c <= '9')
            {
                graph->vex[i].vertex = c;
                graph->vex[i].edge = NULL;//指针初始化为空
                break;
            }
        }
    }

    //3.依次输入m条边的2个顶点v1和v2
    for (int i = 0; i < graph->m; i++) {
        char v1, v2;
        scanf("\n%c %c", &v1, &v2);
        //在邻接点数组vex中查找v1和v2的下标k1和k2
        int k1 = -1, k2 = -1;
        for (int j = 0; j < graph->n; j++) {
            if (graph->vex[j].vertex == v1)
                k1 = j;
            if (graph->vex[j].vertex == v2)
                k2 = j;
        }
        //如果找不到对应的下标，说明输入的顶点信息有误
        if (k1 == -1 || k2 == -1) {
            printf("Error: invalid vertex information.\n");
            exit(0);
        }
        //以k2为下标创建邻接边
        //分配内存并初始化
        ELink* p = (ELink*)malloc(sizeof(ELink));
        p->adjvex = k2;
        p->next = NULL;
        //把这条边加到k1对应的邻接点
        if (graph->vex[k1].edge == NULL)
            graph->vex[k1].edge = p;
        else {
            ELink* tail = graph->vex[k1].edge;
            while (tail->next != NULL)
                tail = tail->next;
            tail->next = p;
        }

        //无向图的话，另加一条边，以k1为下标创建邻接边
        ELink* q = (ELink*)malloc(sizeof(ELink));
        q->adjvex = k1;
        q->next = NULL;
        if (graph->vex[k2].edge == NULL)
            graph->vex[k2].edge = q;
        else {
            ELink* tail = graph->vex[k2].edge;
            while (tail->next != NULL)
                tail = tail->next;
            tail->next = q;
        }
    }
}

// 2.打印图
void printGraph(adjListGraph graph)
{
    // 遍历图的n个邻接点
    for (int i = 0; i < graph.n; i++) {
        // 1.输出顶点数据
        printf("%c", graph.vex[i].vertex);
        // 2.输出当前邻接点关联的邻接边
        // 遍历链表
        ELink* p = graph.vex[i].edge; // 初始化为链表的表头
        while (p) {
            int t = p->adjvex; // 邻接点下标
            printf(" -> %c", graph.vex[t].vertex);
            p = p->next;
        }
        printf("\n");
    }
}
//3.输出图的度数

//（1）无向图
void printDegree(adjListGraph graph) 
{
    //计算每个顶点的度数
    for (int i = 0; i < graph.n; i++) {//遍历每个顶点
        int Degree = 0;

        //计算入度
        for (int j = 0; j < graph.n; j++) { //遍历所有顶点，寻找与当前顶点相关的边
            ELink* p = graph.vex[j].edge;//获取第KJj个顶点的邻接表
            while (p) {//遍历该邻接表中的所有边
                if (p->adjvex == i) {//如果当前边指向当前顶点
                    Degree++;
                    break;//跳出循环，继续计算下一个顶点的入度
                }
                p = p->next;//否则继续遍历该邻接表中的下一条边
            }
        }
  
        printf("顶点%c的度为%d\n", graph.vex[i].vertex, Degree);
    }
}




//4.1深度优先遍历-从下标为n的点出发
void dfs(adjListGraph graph, int n)
{
    visited[n] = 1; // 标记当前节点已被访问
    printf("%c ", graph.vex[n].vertex); // 输出当前访问的节点

    // 递归访问未访问过的邻接点
    ELink* p = graph.vex[n].edge;//将指针p指向下标为n的节点的邻接表链表头
    
    while (p) {//循环遍历所有与当前节点相连的未访问过的邻接点
   //这里通过遍历邻接表链表，依次访问所有与当前节点相连的邻接点。
   // 由于邻接表链表有可能为空，因此需要用while循环判断p是否为空。
        if (!visited[p->adjvex]) {
            dfs(graph, p->adjvex);
        }
        p = p->next;
    }
}

//4.2深度优先遍历-搜所有的点
void dfsAll(adjListGraph graph)
{
    memset(visited, 0, sizeof(visited)); // 初始化状态数组
    for (int i = 0; i < graph.n; i++) {
        if (!visited[i]) {
            dfs(graph, i); // 对未访问过的节点进行深度优先遍历
        }
    }
}

//5.1广度优先遍历-从下标为n的点出发
void bfs(adjListGraph graph, int n)
{
    memset(visited, 0, sizeof(visited)); // 初始化状态数组
    SqCyQueue queue;
    init(&queue); // 初始化队列

    visited[n] = 1; // 标记起始节点已被访问
    printf("%c ", graph.vex[n].vertex); // 输出起始节点
    push(&queue, n); // 将起始节点入队

    while (!isEmpty(queue)) {
        int front;
        pop(&queue, &front); // 出队
        ELink* p = graph.vex[front].edge;
        while (p) {
            if (!visited[p->adjvex]) {
                visited[p->adjvex] = 1; // 标记当前节点已被访问
                printf("%c ", graph.vex[p->adjvex].vertex); // 输出当前访问的节点
                push(&queue, p->adjvex); // 将当前节点入队
            }
            p = p->next;
        }
    }
}

//5.2广度优先遍历-搜所有的点
void bfsAll(adjListGraph graph)
{
    memset(visited, 0, sizeof(visited)); // 初始化状态数组
    for (int i = 0; i < graph.n; i++) {
        if (!visited[i]) {
            bfs(graph, i); // 对未访问过的节点进行广度优先遍历
        }
    }
}







//0.初始化队列
void init(SqCyQueue* q)
{
    q->front = q->rear = 0;
}
//1.判断队列是否为空
int isEmpty(SqCyQueue q)
{
    if (q.front == q.rear) return 1;
    else return 0;
}
//2.判断队列是否已满
int isFull(SqCyQueue q)
{
    return (q.rear + 1) % M == q.front;
}
//3.入队，成功返回1，否则返回0
int push(SqCyQueue* q, ElemType item)
{
    if (isFull(*q)) {
        printf("队列已满，入队失败\n");
        return 0;
    }
    q->data[q->rear] = item;
    q->rear = (q->rear + 1) % M;
    return 1;
}
//4.出队，成功返回1，否则返回0
int pop(SqCyQueue* q, ElemType* item)
{
    if (isEmpty(*q)) {
        printf("队列为空，出队失败!\n");
        return 0;
    }
    else {
        *item = q->data[q->front];
        q->front = (q->front + 1) % M;
        return 1;
    }
}

测试样例：

**有向图的创建、度的计算、dfs和bfs（完整代码）

六、最小生成树

      

1.克鲁斯卡尔（Kruskal）方法

2.普里姆（Prim）算法

七、最短路径问题

一、Dijkstra算法（源点到某一顶点的最短路径）

Q:对于对于给定的带权连通无向图，从某源点到图中各顶点的最短路径构成的生成树是否是该图的最小生成树？？

不一定相同。

二、Floyd算法（任意两个顶点之间的最短路径）

八、AOV网与拓扑排序

九、AOE网与关键路径

1、AOE网的定义

2、AOE网的特点

3、AOE网的存储方法

4、关键路径

NNLYF_
关注
  • 9
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
数据结构和算法-思维导图.jpg
05-02
算法与数据结构思维导图, 完全详细版本 开始学习算法与数据结构的最好指导, 方便初学者找到学习路线以及中等水平者找到提升路径
大学数据结构实验-约瑟夫环（附源码+实验报告）
12-31
一开始任选一个正整数作为报数值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。...适合人群：大学数据结构实验课 内含：源码+实验报告（实验内容；设计思想；主要算法框架；调试报告；实验总结）
【408数据结构】考点总结（更新ing）
qq_36674053的博客
11-10 3912
408数据结构考点分析总结
数据结构编程题集锦（更新ing）
Marcus1231的博客
11-24 1248
数据结构编程题一、线性结构（一）线性表（二）栈与队列（三）广义表与多重链表二、数组与字符串三、树（一）二叉树（二） 一、线性结构 （一）线性表 （二）栈与队列 1.括号匹配 检查一段C语言代码的小括号( )、 中括号 [ ] 和大括号{ } 是否匹配。 2.双端队列（双向链表版）双端队列（顺序表版本） （三）广义表与多重链表 二、数组与字符串 三、树 （一）二叉树 （二） ...
数据结构-------逻辑结构与物理结构
m0_63718525的博客
01-10 467
一、逻辑结构 指数据元素之间的关系，是我们想像出来的，并没有实质性的将其存储在计算机中 线性结构 线性结构中的数据元素之间是一对一的关系 树形结构 数据元素之间存在一对多的层次关系 图形结构 数据元素是多对多的关系 二、物理结构 指数据的逻辑结构在计算机中的具体存储形式 顺序存储结构 开辟一组连续的空间存储数据 通常用数组来实现，数组中空间本身是连续的，保证了数据之间的关系 通过an=a1+（n-1）*d的关系，快速查找下一数据位置 链式存储结构 开辟一组...
866数据结构笔记 - 第八章 排序
qq_45331246的博客
11-16 1715
866数据结构、湖南大学考研、排序
【数据结构】持续更新ing
weixin_46577188的博客
04-12 1084
对C++/STL容器的数据结构（包括序列式容器list、vector、priority_queue、deque、stack、queue和关联式容器map/set、multimap/set、unordered_map/set、unordered_multimap/set等）、Redis的数据结构（string、list、hash、set、zet等）、MySql的数据结构、LevelDB/RocketDB的数据结构等。 低层实现主要包括红黑树、哈希表、B+树、LSM-Tree、压缩链表、双向链表、跳表等。。。。
数据结构与算法 知识点总结（下）--树与图（ING）
Techblog of HaoWANG
03-24 465
本文延续《数据结构与算法 知识点总结》系列，上、中可查看本人另外两篇文章。 链接：https://blog.csdn.net/hhaowang/article/details/88016180、https://blog.csdn.net/hhaowang/article/details/88365333 【知识体系】 4. 树（Trees） 5. 图 ...
【数据结构与算法】笔记 持续更新ing！
2302_79258441的博客
01-25 893
关于C语言版数据结构与算法在学习之中的笔记，有错误望指正！
【数据结构与算法】浙大数据结构MOOC课堂测试合集 - 超全版，含解析【更新ing】
这里是 F菌的进阶之路。
05-04 2012
浙江大学，数据结构与算法，MOOC课堂测试，超全版，基础题，含解析。
数据结构---七个大排序(手写实例未完结版)
jinjin_csdn的博客
11-03 28
基数排序，堆排序，马上就来了，未完结ing…博主后续有时间再使用电脑绘图，仔细分析分析 详细写写，
SpringBoot+Vue全栈开发--学习笔记(更新ing)
weixin_52973401的博客
10-27 2612
SpringBoot+Vue全栈开发
湖南大学-数据结构-期末试题【2016-2019】.zip
10-25
数据结构是计算机科学中的核心课程，它探讨了如何在计算机中高效地组织和管理数据，以便于进行各种操作。湖南大学的数据结构期末试题涵盖了这门课程的重要概念和技术，旨在检验学生对这些知识的理解和应用能力。以下...
【2000-2018】湖南大学信息科学与工程学院866数据结构历年考研真题汇编.pdf
10-25
【2000-2018】湖南大学信息科学与工程学院866数据结构历年考研真题汇编.pdf
数据结构——二叉树性质
最新发布
鲸落博客
07-23 285
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
数据结构-＞线性结构-＞顺序存储-＞静态链表
qq_68495605的博客
07-20 214
【代码】数据结构-＞线性结构-＞顺序存储-＞静态链表。
数据结构(5.2_3)——二叉树的存储结构
m0_65240792的博客
07-19 312
1%29%5D1。
数据结构~~顺序表
TU^的博客
07-22 634
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
Java实现七大排序（一）
lllsure的博客
07-23 378
插入排序、希尔排序、选择排序、堆排序
leecode刷题指南数据结构python
10-19
这些引用提供了一些关于如何学习数据结构和算法以及如何在LeetCode上刷题的建议。如果你想在LeetCode上刷题，可以按照以下步骤进行： 1. 打好数据结构和算法的基础，可以使用《大话数据结构》这本书作为入门教材。 2. 刷LeetCode上的简单题和中等难度的题，可以按照书中的章节来刷，对于想刷树这一部分的话，就把树相关的习题挑出来，集中刷。不需要追求刷的题的数量，一个章节能做个十来道就已经不错了。 3. 在刷题的过程中，可以使用严的教材作为补充，巩固理论知识。 4. 刷题的目的是为了掌握数据结构和算法这些理论知识，所以不要追求刷题的数量，而是要注重理解和掌握。 5. 如果从头开始学习的话，可以按照打基础，巩固基础，进阶的步骤进行，一天两到三个小时的话，三个月应该能搞完。 关于LeetCode刷题指南和数据结构的Python实现，你可以在LeetCode官网上找到相关的题目和解答。同时，也可以在网上找到一些Python实现的数据结构和算法的代码示例。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值