数据结构代码汇总（6）----终章---图论

已于 2024-06-21 16:55:30 修改
阅读量459 收藏 10
点赞数 8
分类专栏： 数据结构代码 文章标签： 数据结构 图论 深度优先
于 2024-06-18 16:49:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzdhs/article/details/139747686
版权

本文将介绍图论相关算法，难度较大，如果有写的不对的地方欢迎评论区探讨
本文只讲图论算法，基础知识略过不讲
由于图论算法书上的代码可读性以及可执行性不高，故本文会将这些算法一一实现，长度会比较长，这是最伟大的一集（^ _ ^）这些算法仅使用一个测试点进行测试，如果大家写的时候遇到了错误，请反馈给我
一、图的存储与创建（书上的有点啰嗦，不简洁，不适宜考试中写）
1.邻接矩阵

typedef struct
{
    int mat[50][50];//矩阵
    int vexnum,arcnum;//顶点数，边数
}graph;//图的定义，这个存储方式比书上简化多了，考试大多是int类型，所以此定义是对于考试来说非常方便的

2.邻接表

typedef struct arcnode
{
    int num;
    struct arcnode *next;
}arcnode;//中间点

typedef struct vernode
{
    int data;
    arcnode *firstarc;
}vernode;//顶点

typedef struct
{
    vernode ver[50];
    int vexnum,arcnum;//顶点数，边数
}graph;

3.邻接矩阵的创建，课本217页算法7.1
有两种方法，一种是直接输入一个矩阵，此种方法非常简单，按照输入一般的矩阵就可以输入进去了
第二种是输入两个顶点及边的权值，如果这种方法，也不是很难

void creategraph(graph &g)//此处是c++写法，传的引用
{
    int i,j;
    scanf("%d %d",&g.vexnum,&g.arcnum);
    for(i=1;i<=g.vexnum;i++)
    {
        g.ver[i]=i;
        for(j=1;j<=g.vexnum;j++)
        {
            g.mat[i][j]=(i==j)?0:32767;//初始化，同一点则赋0，不是一个点则赋32767（一个特别大的数，表示不可达，32767是int类型上限，书上是INFINTY）
        }
    }

    int num1,num2,weigh;
    for(i=1;i<=g.arcnum;i++)
    {
        scanf("%d %d %d",&num1,&num2,&weigh);
        g.graph[num1][num2]=weigh;
        g.graph[num2][num1]=weigh;//有向网就没有这句了
    }
}

4.邻接表的创建（此算法课本好像没有？）

//需要先输入n（顶点的个数）
for(i=1;i<=n;i++)
    {
        scanf("%d",&num);
        g.ver[i].data=num;
        visited[i]=0;//全局变量，方便后面做遍历
        g.ver[i].firstarc=NULL;//初始化，千万要做
    }

    while(1)
    {
        scanf("%d %d",&a,&b);
        if(a==-1&&b==-1)break;//结束条件
        arcnode *p=(arcnode*)malloc(sizeof(arcnode));
        p->num=b;
        p->next=g.ver[a].firstarc;//头插法建立
        g.ver[a].firstarc=p;
    }

十字链表存储方法考试不考，此处不讲
二、图的遍历（225页的算法不讲，因为它只是思路，实现不了）
1.深度优先（递归，课本226页7.5-7.6）
1.1邻接矩阵实现的

void dfs(graph g,int v0)
{
    printf("%d ",v0);
    visited[v0]=1;//全局数组
    int i;
    for(i=0;i<g.vexnum;i++)
    {
        if(!visited[i] && g.mat[v0][i]==1)
            dfs(g,i);
    }
}

1.2邻接表实现的

void DFS(graph *g,int n)
{
    arcnode *p;
    int i;
    visited[n]=1;
    printf("%d ",g->ver[n].data);
    p=g->ver[n].firstarc;
    while(p)
    {
        i=p->num;
        if(!visited[i])
            DFS(g,i);//递归
        p=p->next;//按深度遍历就是一条路走到黑~
    }
}

1.3非递归形式的DFS，226页2.7

void push(stack *s,int n)//栈的操作
{
    s->a[++(s->top)]=n;
}

int pop(stack *s)
{
    int n=s->a[(s->top)--];
    return n;
}

int visited[50];

void DFS(graph g,int v0)
{
    stack s;
    s.top=-1;//栈的初始化，对应InitStack函数
    push(&s,v0);
    int v,w;
    arcnode *temp;//
    while(s.top!=-1)
    {
        v=pop(&s);
        if(!visited[v])
        {
            cout<<v<<" ";
            visited[v]=1;
            temp=g.ver[v].firstarc;
            if(temp)//判断邻接顶点是否为空，是则求出
                w=g.ver[v].firstarc->num;
            else
                w=-1;//否则赋值-1
            while(w!=-1)
            {
                if(!visited[w])
                    push(&s,w);
                if(temp->next)
                    w=temp->next->num;//同上
                else
                    w=-1;
                temp=temp->next;
            }
        }
    }
}

2.广度优先遍历（228页7.8）

typedef struct
{
    int arr[50];
    int front;
    int rear;
}seqquene;

void init(seqquene *a)
{
    a->front=a->rear=0;
}

void enter(seqquene *q,int x)
{
    q->arr[q->rear]=x;
    q->rear=(q->rear+1)%50;
}

int del(seqquene *q)
{
    int x=q->arr[q->front];
    q->front=(q->front+1)%50;
    return x;
}

int visited[50];

void BFS(graph g,int v0)
{
    cout<<v0<<" ";
    visited[v0]=1;
    seqquene q;
    init(&q);//队列的初始化，对应InitStack函数
    enter(&q,v0);
    int v,w;
    arcnode *temp;//
    while(q.rear!=q.front)
    {
        v=del(&q);
        temp=g.ver[v].firstarc;
        if(temp)//判断邻接顶点是否为空，是则求出
            w=g.ver[v].firstarc->num;
        else
            w=-1;//否则赋值-1
        while(w!=-1)
        {
            if(!visited[w])
            {
                cout<<w<<" ";
                visited[w]=1;
                enter(&q,w);
            }
            if(temp->next)
                w=temp->next->num;//同上
            else
                w=-1;
            temp=temp->next;
        }
    }
}

三、图的应用
1.简单路径，231页7.9

int pre[50]={-1};

void printpath(int n)
{
    int path[50];//存储路径的数组
    int pathIndex = 0;//路径数组的索引

    //从目标顶点开始，逆向追踪到起始顶点
    for(int current=n;current!=-1;current=pre[current])
    {
        path[pathIndex++]=current;//将顶点添加到路径数组中
    }

    //打印路径，路径是逆序的，所以需要反转打印
    for(int i=pathIndex-1;i>=0;i--)
    {
        cout<<path[i]<<" ";
    }
    cout<<endl;
}

void DFS(graph *g,int u,int v)
{
    int w;
    if(u==v)
    {
        printpath(v);
        return;
    }
    arcnode *p=g->ver[u].firstarc;
    if(p)
        w=g->ver[v].firstarc->num;
    else
        w=-1;
    while(w!=-1)
    {
        if(pre[w]==-1)
        {
            pre[w]=u;
            DFS(g,w,v);
        }
        if(p->next)
            w=p->next->num;
        else
            w=-1;
        p=p->next;
    }
}

注：没有写主函数的邻接表实现的操作，主函数均为以下的

int main()
{
    graph g;
    int i,a,b,num,n;
    cin>>n;
    for(i=1;i<=n;i++)
    {
        scanf("%d",&num);
        g.ver[i].data=num;
        pre[i]=-1;//全局变量，方便后面做遍历
        g.ver[i].firstarc=NULL;//初始化，千万要做
    }

    while(1)
    {
        scanf("%d %d",&a,&b);
        if(a==0&&b==0)break;//结束条件
        arcnode *p=(arcnode*)malloc(sizeof(arcnode));
        p->num=b;
        p->next=g.ver[a].firstarc;//头插法建立
        g.ver[a].firstarc=p;
    }
    DFS(&g,1,4);
    return 0;
}

2.最小生成树，prim算法，233页算法7.10

#include <iostream>

using namespace std;

typedef struct
{
    int ver[100];
    int graph[100][100];
    int vexnum,arcnum;
}Graph;//

typedef struct
{
    int adjvex;
    int low;
}closedge;

int all=0;//最小生成树的权值之和

void creategraph(Graph &g)//生成图的算法，前面讲过了
{
    int i,j;
    scanf("%d %d",&g.vexnum,&g.arcnum);
    for(i=1;i<=g.vexnum;i++)
    {
        g.ver[i]=i;
        for(j=1;j<=g.vexnum;j++)
        {
            g.graph[i][j]=(i==j)?0:32767;
        }
    }

    int num1,num2,weigh;
    for(i=1;i<=g.arcnum;i++)
    {
        scanf("%d %d %d",&num1,&num2,&weigh);
        g.graph[num1][num2]=weigh;
        g.graph[num2][num1]=weigh;
    }
}

int mini(Graph &g,closedge *s)
{
    int i,min,loc=-1;
    min=32767;
    for(i=1;i<=g.vexnum;i++)
    {
        if(min>s[i].low && s[i].low!=0)//选最小边
        {
            min=s[i].low;
            loc=i;
        }
    }
    return loc;
}

void prim(Graph &g,int n)
{
    int i,j,k;
    closedge s[100];
    s[1].low=0;

    for(i=2;i<=g.vexnum;i++)//初始化
    {
        s[i].adjvex=n;
        s[i].low=g.graph[n][i];
    }
    cout<<"1";
    for(k=1;k<g.vexnum;k++)
    {
        j=mini(g,s);//选取当前最小边
        all+=s[j].low;//最小边权值加入到最小生成树的总权值中
        printf(" %d",j);//输出边的信息
        s[j].low=0;//
        for(i=1;i<=g.vexnum;i++)
        {
            if(g.graph[j][i]<s[i].low)//更新边的信息
            {
                s[i].low=g.graph[j][i];
                s[i].adjvex=j;
            }
        }
    }
}

int main()
{
    Graph g;
    creategraph(g);
    prim(g,1);
    cout<<endl<<all;
    return 0;
}

3.拓扑排序，239页7.11 7.12

#include <iostream>
#include <stack>
using namespace std;

int a[50];
int n=0;
typedef struct arcnode
{
    int adjvex;
    struct arcnode *next;
}arcnode;

typedef struct vernode
{
    int data;
    arcnode *first;
}vernode;

typedef struct
{
    vernode ver[50];
    int vexnum,arcnum;
}graph;


void findid(graph &g,int indegree[])//求入度
{
    int i;
    arcnode *p;
    for(i=0;i<g.vexnum;i++)//初始化入度数组
        indegree[i]=0;
    for(i=0;i<g.vexnum;i++)
    {
        p=g.ver[i].first;//求每个顶点的入度
        while(p)
        {
            indegree[p->adjvex]++;//p指向的点入度+1，不停循环
            p=p->next;
        }
    }
}

void topsort(graph &g)
{
    stack<int> s;//此处偷懒了，调用stl，如果考试的时候不让用请使用前面栈操作来替换
    int indegree[50];
    int i,cnt,k;
    arcnode *p;
    findid(g,indegree);//求入度
    for(i=0;i<g.vexnum;i++)
    {
        if(!indegree[i])//入度为0则进栈
            s.push(i);
    }
    cnt=0;
    while(!s.empty())
    {
        i=s.top();
        a[n++]=i;//先存到数组中，一会一起输出
        s.pop();//出栈
        cnt++;
        p=g.ver[i].first;
        while(p)
        {
            k=p->adjvex;
            indegree[k]--;//删掉节点对应的边
            if(!indegree[k])//入度为0就进栈
                s.push(k);
            p=p->next;
        }
    }
    if(cnt < g.vexnum)
        cout<<"ERROR";
    else
    {
        for(i=0;i<n;i++)
            cout<<a[i]<<" ";
    }
}

int main()
{
    graph g;
    int i,j,n;
    arcnode *p,*q;
    cin>>g.vexnum;
    for(i=0;i<g.vexnum;i++)//初始化
    {
        g.ver[i].first=NULL;
        g.ver[i].data=i;
    }
    //此处是输入的邻接矩阵，但存储方式使用邻接表
    for(i=0;i<g.vexnum;i++)//尾插法创建图
    {
        for(j=0;j<g.vexnum;j++)
        {
            cin>>n;
            if(n && g.ver[i].first==NULL)
            {
                p=new arcnode;
                p->adjvex=j;
                g.ver[i].first=p;
                p->next=NULL;
            }
            else if(n)
            {
                q=g.ver[i].first;
                while(q->next)//尾插法，找到最后
                    q=q->next;
                p=new arcnode;
                q->next=p;
                p->next=NULL;
                p->adjvex=j;
            }
        }
    }
    topsort(g);
    return 0;
}

关键路径不考此处略去

4.迪杰斯特拉最短路径，248页7.15，全书最想吐槽的算法，此算法书上的可读性极差（个人感觉），addtail算法根本不给，path的定义也不明确。。。

#include <iostream>

using namespace std;

typedef struct
{
    int mat[50][50];//矩阵
    int vexnum,arcnum;//顶点数，边数
}graph;

int dist[50],path[50][50];//dist是最短路径的长度，path是最短路径的路径，其实这两个就是个整型数组，不要被书上的定义吓到了

int member(int n,int s[])
{
    int i;
    for(i=0;i<50;i++)
    {
        if(s[i]==n)
            return 1;
    }
    return 0;
}

void addtail(int path[][50],int v0,int v)
{
    int i=0;
    for(i=0;path[v0][i]!=-1;i++);//注意这里的分号，别抄错了
    path[v0][i]=v;
}

void dij(graph g,int v0)//其余参数以全局变量的形式带入
{
    int s[50];//最短路径点的集合，其实也是个整型数组
    int i,j,k,min;
    int scount=0;//控制s集合的计数器
    for(i=0;i<g.vexnum;i++)
    {
        //path数组在主函数已经初始化过了
        dist[i]=g.mat[v0][i];
        if(dist[i]<32767)
        {
            path[i][0]=v0;
            addtail(path,i,i);
        }
    }
    for(i=0;i<50;i++)//
    {
        s[i]=-1;
    }

    s[scount++]=v0;//纳入s集合，表示已经访问过了，类似visited数组

    for(i=0;i<g.vexnum;i++)
    {
        min=32767;
        for(j=0;j<g.vexnum;j++)
        {
            if(!member(j,s) && dist[j]<min)
            {
                k=j;
                min=dist[j];
            }
        }
        if(min==32767)return;

        s[scount++]=k;

        for(j=0;j<g.vexnum;j++)
        {
            if(!member(j,s) && g.mat[k][j]!=32767 && (dist[k]+g.mat[k][j]<dist[j]))//权值小就改变，类似prim算法
            {
                dist[j]=dist[k]+g.mat[k][j];
                for(int m=0;path[k][m]!=-1;m++)
                {
                    addtail(path,j,path[k][m]);//把对应的节点路径上都添加此节点
                }
                addtail(path,j,k);
            }
        }
    }
}

int main()
{
    graph g;
    int i,j,v0;//v0是源点
    cin>>g.vexnum;
    cin>>v0;

    for(i=0;i<g.vexnum;i++)
    {
        for(j=0;j<g.vexnum;j++)
        {
            cin>>g.mat[i][j];
            if(g.mat[i][j]==0)
                g.mat[i][j]=32767;//初始化为不可达
        }
    }

    for(i=0;i<50;i++)
    {
        for(j=0;j<50;j++)
            path[i][j]=-1;//初始化
    }
    dij(g,v0);
    for(i=0;i<g.vexnum;i++)
    {
        if(dist[i]==32767)
        {
            cout<<"Vertex "<<i<<" is unreachable from "<<v0<<endl;
        }
        else
        {
            cout<<"Shortest distance from "<<v0<<" to "<<i<<" is "<<dist[i]<<endl;
            cout<<"Path: "<<v0;
            for(int step=0;path[i][step]!=-1;step++)
            {
                cout<<" -> "<<path[i][step];//输出路径
            }
            cout<<endl;
        }
    }
    return 0;
}

5.弗洛伊德最短路径，251页7.16
下面的代码是基于这道题实现的
在这里插入图片描述

#include <iostream>

using namespace std;

typedef struct
{
    int vexnum,edgenum;
    int matrix[50][50];
}graph;

int dist[50][50];
int path[50][50];
void flyd(graph g)
{
    int i,j,k;

    for(i=0; i<g.vexnum; i++)
    {
        for(j=0; j<g.vexnum; j++)
        {
            dist[i][j]=g.matrix[i][j];//初始化
            if(i != j && path[i][j] != 9999)
                path[i][j]=j;
        }
        path[i][i]=0;
        dist[i][i]=0;
    }

    for(k=0; k<g.vexnum; k++)
    {
        for(i=0; i<g.vexnum; i++)
        {
            for(j=0; j<g.vexnum; j++)
            {
                if(dist[i][k] == 9999 || dist[k][j] == 9999)//这句话是为了减少后面判断的
                    continue;
                if(dist[i][j] > (dist[i][k]+dist[k][j]))
                {
                    dist[i][j]=dist[i][k]+dist[k][j];
                    path[i][j]=path[i][k];//更新路径
                }
            }
        }
    }
    for(i=0;i<g.vexnum;i++)
    {
        for(j=0;j<g.vexnum;j++)
        {
            cout<<"from "<<i<<" to "<<j<<": dist = "<<dist[i][j];
            k=i;
            cout<<" path:";
            while(k!=j)
            {
                cout<<k<<" ";
                k=path[k][j];
            }
            cout<<j<<" "<<endl;
        }
    }

}
int main()
{
    int i,j;
    graph g;
    cin>>g.vexnum;
    for(i=0;i<g.vexnum;i++)
    {
        for(j=0;j<g.vexnum;j++)
        {
            cin>>g.matrix[i][j];
        }
    }
    flyd(g);
    return 0;
}

本系列文章到此结束，由于查找和排序书上的代码可抄性非常高，我就不再翻译了，大家对算法有什么不理解的地方欢迎评论，实在不理解的就请先记下来，因为我写的这些代码真的能跑。
图论这一篇文章是最难写的，因为好多操作书上没有给，不管怎么说，我还是总结了一遍，希望对大家的期末复习有所帮助，感谢大家的阅读。

lzdhs
关注
  • 8
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2022级图论-欧拉回路和最短路-题解
01-28
在计算机科学和数学中，图论是一门重要的理论，它研究由顶点和连接这些顶点的边组成的结构，即图。在2022级的图论课程中，学生们将深入学习两个核心概念：欧拉回路和最短路径。 **欧拉回路** 欧拉回路是图论中的一...
Python-Python描述的数据结构和算法
08-10
在Python中，数据结构和算法是核心概念，它们对于高效地编写代码和解决复杂问题至关重要。本篇将深入探讨Python中的主要数据结构，如列表、元组、集合、字典，以及常用的算法，包括排序、搜索和图论等。 1. **数据...
swift-100天iOS数据结构与算法实战
08-15
这是一段旅程，旨在帮助开发者从初级阶段提升到高级水平，理解和运用数据结构与算法来优化代码性能。 首先，我们要理解数据结构是存储和组织数据的方式，它直接影响程序的效率和可维护性。在Swift中，常见的数据...
QC-LDPC码源代码
02-09
MATLAB作为一款强大的数值计算和数据可视化工具，是实现此类编码的理想平台。 首先，我们来深入理解QC-LDPC码的基本概念。LDPC码由一组稀疏的 parity-check矩阵 定义，该矩阵中的非零元素较少，从而允许并行处理和...
数据结构——二叉树性质
鲸落博客
07-23 291
这个性质很好记忆，观察一下图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 215
【代码】数据结构-＞线性结构-＞顺序存储-＞静态链表。
数据结构(5.2_3)——二叉树的存储结构
m0_65240792的博客
07-19 313
1%29%5D1。
《数据结构-用C语言描述第三版》课后答案 第三章
m0_62469100的博客
07-19 1073
b[2] = 2;b[n+1] = 2;i>=2;i--){若调用 bin ( A ,5)，给出 A 数组中第1个到第6个数组元素的值。答：数组中的值为每次递归将后面一个元素赋值为2，然后前面的元素分别加等其前面的元素。
《数据结构1800题》基础回合总结——第2章 线性表
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-23 278
和删除第一个结点不必另作判断。另外，不论链表是否为空，链表指针不变。这个要能够表达清楚。如果不设置头结点，边界情况需要特殊处理~应用题看了一下，不想在基础回合更新了，其实程序填空各位也可以暂时忽略——主要是使插入和删除等操作统一，在第一个元素之前插入。如果能保证客观题正确率100%，这本题就没白刷~刷《1800》的意义在于，
数据结构 - 队列（精简介绍）
mydaily_的博客
07-19 469
循环队列（Circular Queue），也称为环形队列，是一种队列数据结构，它将队列的最后一个位置连接到队列的第一个位置，使其形成一个环。在循环队列中，队列的前端和后端都可以绕回到数组的起始位置，从而有效利用数组的空间。单端队列升级版，允许在队头和队尾都进行元素的插入删除操作。，队列中元素会根据某种规则进行优先级排序。只能从尾部插入，头部取出元素。普通队列为单端队列，先进先出（FIFO）
【手撕数据结构】把玩顺序表
apple_61439616的博客
07-19 910
顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组线性结构又是什么意思，这就不得不提到线性表了线性表（linear list）是n个具有相同特性的数据元素的有限序列线性表是⼀种在实际中⼴泛使 ⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串注意的是，他在逻辑结构上一定是连续的，但在物理结构上不一定是连续的.线性表在物理上存储时，通常以数组和链式结构的形式存储那么我们知道，数组在内存中存储也是连续的，并且也是类型一致，那么他与顺序表的区别是什么呢.
数据结构（特殊二叉树-平衡二叉树）
weixin_65029285的博客
07-23 576
待删除节点左右子树非空，则根据左右子树的高度，选择高的一边子树，如果是左子树高，选择左子树中的最大节点赋值给待删除节点，然后再左子树中继续删除该最大节点，相当于继续处理情况1或情况2；由于节点的位置要受到相互之间值的影响，并且在往平衡二叉树中添加节点或者删除节点前，二叉树本身是平衡的，所以只可能在最后操作的节点附近不满足平衡条件，因此需要在该过程中对该节点进行判断并调整。如果一个搜索二叉树呈现或接近单支状，它的查找效率很低，很接近链表，因此如果能让它平衡时，查找效率最高。待删除的节点是叶子节点，直接删除。
数据结构之栈详解
最新发布
m0_73634434的博客
07-23 327
栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。，相对而言数组的结构实现更优一些。栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。整合以上我们来实现栈，下面是实现栈的完整代码。压栈：栈的插入操作叫做进栈/插栈/入栈，这里定长的静态栈的结构，实现中一般不实用。所以我们主要实现下面的支持动态增长的栈。出栈：栈的删除操作叫做出栈。->6. 查看栈中有没有元素。栈所需要实现的一些功能。->5. 查看栈的大小。栈的实现一般可以使用。->4. 删除栈元素。
《数据结构：栈和队列》
2401_83305953的博客
07-19 624
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行插入和删除操作的一端称为栈顶，另一端称为栈底。概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)队列也可以由数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。：栈的插入操作叫做进栈/压栈/入栈/，入数据在栈顶。
从零开始学习嵌入式----数据结构
D1557329860的博客
07-19 302
数据结构知识。数据结构是计算机科学中用于组织、管理和存储数据的方式。不同的数据结构可以提供不同的功能，以满足不同的应用需求。
数据结构——二叉树定义
鲸落博客
07-23 108
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
数据结构第一章概述（李春葆）
qq_62830324的博客
07-19 1017
分析问题，确定数据模型设计相应的算法编写程序，运行并调试程序，直到出现正确的答案在C语言中，不同数据类型在打印时使用不同的占位符，同时它们占用的字节数也有所不同。int%d或%i占用字节数：通常是4字节（具体取决于系统和编译器）float%f占用字节数：4字节double%lf占用字节数：8字节long%ld或%li占用字节数：通常是8字节（具体取决于系统和编译器）char%c占用字节数：1字节所以这里5.2f 的意思是，总宽度为5个字符，小数点后保留两位。
学习记录——day17 数据结构 队列 链式队列
weixin_64918301的博客
07-23 235
1、队列也是操作受限的线性表:所有操作只能在端点处进行，其删除和插入必须在不同端进行2、允许插入操作的一端称为队尾，允许删除操作的一端称为队头3、特点:先进先出(FIFO)4、分类：顺序存储的栈称为顺序栈链式存储的队列，称为链式队列。
Tarjan与2-SAT图论算法详解PPT
Tarjan算法是图论中常见的一种方法，可以用于缩点和求强连通分量。 Tarjan算法的重要性在于它可以将有向图中的强连通分量缩成一个点，从而将原图转化为一个有向无环图。这个过程可以通过DFS来实现。首先对于一个图...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值