数据结构总结（图）

最新推荐文章于 2022-05-12 15:29:51 发布
最新推荐文章于 2022-05-12 15:29:51 发布
阅读量346 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43266513/article/details/103250698
版权

  图这里存的就是复杂数据了，算法普遍较难，并有很多细节需要经常看。

本章主要内容有，图的逻辑结构，存储结构，连通性，最小生成树，最短路径，AOV,AOE 网等问题。

一，图的逻辑结构

图的部分知识在离散数学已经有所介绍，如有向图顶点度（入度=出度=边数），注意有向图连通也是任意俩点之间连通，不是无向图有边串连所有点的形式。

稀疏图：称边数很少的图为稀疏图；

稠密图：称边数很多的图为稠密图

连通分量：非连通图的极大连通子图称为连通分量。

生成树：n个顶点的连通图G的生成树是包含G中全部顶点的一个极小连通子图。

eg：有7个顶点保证图在任何情况下都连通，最少要多少条边？

16条，6个点做完全图，一个点连上

   图的遍历有深度优先搜索（栈辅助）、广度优先搜索（队辅助）两种主要方式。

二，图的存储结构

1，邻接矩阵（数组表达法）

 关于顶点元素的集合一定用顺序存储。

注意无向图在构造邻接矩阵是对称的edge[i][j]=edge[j][i]=1;

DFS针对连通图的遍历
int visited[MaxSize];
template <class T>
void MGraph::DFSTraverse(int v){
     cout<<vertex[v]; visited [v]=1;//记录是否被访问过
     for (j=0; j<vertexNum; j++)
         if (arc[v][j]==1 && visited[j]==0)
            DFSTraverse( j );
}
///
BFS
int visited[MaxSize];
template <class T>
void MGraph::BFSTraverse(int v){     
    front=rear=-1;
    cout<<vertex[v]; visited[v]=1;  Q[++rear]=v; 
    while (front!=rear)
     {
         v=Q[++front];   
         for (j=0; j<vertexNum; j++)
            if (arc[v][j]==1 && visited[j]==0 ) {
                  cout<<vertex[j];visited[j]=1;
                  Q[++rear]=j;
            }
      }
}

2，邻接表（出边表）

对于图的每个顶点vi，将所有邻接于vi的顶点链成一个单链表，称为顶点vi的边表（对于有向图则称为出边表）

所有边表的头指针和存储顶点信息的一维数组构成了顶点表。

struct ArcNode{   
      int adjvex; 
      ArcNode *next;
};

template <class T>
struct VertexNode{
      T vertex;
      ArcNode *firstedge;//初始化时赋空
};
链表的DFS
template <class T>
void ALGraph::DFSTraverse(int v){        
    cout<<adjlist[v].vertex;  visited[v]=1;
    p=adjlist[v].firstedge;    
    while (p!=NULL)     {
        j=p->adjvex;
        if (visited[j]==0) DFSTraverse(j);
    p=p->next;           
    }
}


链表的BFS
template <class T>
void ALGraph::BFSTraverse(int v){
   front=rear=-1;   
   cout<<adjlist[v].vertex;    visited[v]=1;   Q[++rear]=v;   
   while (front!=rear)  {
       v=Q[++front];    p=adjlist[v].firstedge;    
       while (p!=NULL)  {
            j= p->adjvex;
            if (visited[j]==0) {
                cout<<adjlist[j].vertex;  visited[j]=1; Q[++rear]=j;
            }
            p=p->next;
       }
    }
}

3，图的其余存储方法还有有向图的十字链表法、无向图的邻接多重表、边集数组。

边集数组：对边依次进行处理时用、最小代价生成树

利用两个一维数组

一个数组存储顶点信息，
另外一个数组存储边及其权

数组分量包含三个域：边所依附的两个顶点，权值

三，最小生成树，连通所有点，权值最小

1，prim算法（加点法，适用稠密图）

int minedge(int lowcost[],int n){
    int m=100,p;
    for(int i=0;i<n;i++)
    if(lowcost[i]!=0&&m>lowcost[i]){
    m=lowcost[i];
    p=i;
    }
    return p;}
Void prime(MGraph G){
    for(int i=1;i<G.vertexNu;i++){     
        lowcost[i]=G.arc[0][i];  adjvex[i]=0;//从v0开始生成树，low cost记录与v0邻接边的权
    }
    lowcost[0]=0;
    for(i=1;i<G.vertexNum;i+++){
        k=MinEdge(lowcost,G.vertexNum)//找最小权
        cout<<K<<adjvex[k]<<lowcost[k];
        lowcost[k]=0;                  //将找到的点列入树中
              for(j=1;j<G.vertexNum;j++)
          if((G.arc[k][j]<lowcost[j]){
              lowcost[j]=G.arc[k][j];//更新关于树的结点权
              arcvex[j]=k;
           }
    }
}

2，kruskal算法（加边法，稀疏图）

使用边集数组，并查集，parent数组判断是否俩点属于同一个连通分量，不属于后一树的parent变前一树的值。

#include<bits/stdc++.h>
using namespace std;
struct bian                  //边集数组
{
    int from;
    int to;
    int weight;
};
bool cmp(bian a,bian b)           //使sort按权值排序
{
    return a.weight<b.weight;
}
int findd(int *parent,int o)     //找根结点
{
    int ff;
    ff=o;
    while(parent[ff]>-1)
        ff=parent[ff];
    return ff;
}
int main()
{
    int m,n;
    cin>>n>>m;
    int parent[99];
    int vis[99][99];
    bian eg[99];
    int f=0;
    for(int i=0; i<n; i++)
        parent[i]=-1;         //初始都是单个点，n个树
    for(int i=0; i<n; i++)
        for(int j=0; j<n; j++)
            vis[i][j]=0;      //都没访问过
    for(int i=0; i<n; i++)
        for(int j=0; j<n; j++)
        {
            int p;
            cin>>p;
            if(p!=0&&p!=100&&vis[i][j]==0)
            {
                eg[f].from=i;
                eg[f].to=j;
                eg[f].weight=p;
                vis[i][j]=1;           //无向图
                vis[j][i]=1;
                f++;
            }
        }
    sort(eg,eg+f,cmp);
    int k=0,beginn,endd,countt=0;
    for(k=0; k<f; k++)
    {
        beginn=eg[k].from;
        endd=eg[k].to;
        int x,y;
        x=findd(parent,beginn);
        y=findd(parent,endd);
        if(x!=y)
        {
            cout<<beginn+1<<" "<<endd+1<<" ";//输出结点
            parent[y]=x;
            countt++;
            if(countt==n-1)
                break;
        }
    }

}

四，最短路径

在网图中，最短路径是指两顶点之间经历的边上权值之和最短的路径。

1，dijkstra算法（单元点到其他顶点的最短路径，不能解决负权问题）

路径长度递增，解n-1条路的数值

数组dist[n]：每个分量dist[i]表示当前所找到的从始点v到终点vi的最短路径的长度。初态为：

  若从v到vi有弧，则dist[i]为弧上权值；否则置dist[i]为∞

数组path[n]：path[i]是一个字符串，表示当前所找到的从始点v到终点vi的最短路径。初态为：若从v到vi有弧，则path[i]为vvi；否则置path[i]空串。

数组s[n]：存放源点和已经找到最短路径的终点，其初态为只有一个源点v。

#include<iostream>
#include<string>
#include<cmath>
using namespace std;
const int MaxSize=10;
const int Max=1000;
class MGraph
{
public:
    MGraph(int n,int e);
    void Dijkstra(int v,int x);
private:
    int vertexnum;
    int arcnum;
    int arc[MaxSize][MaxSize];
    string vertex[MaxSize];
};
MGraph::MGraph(int n,int e){
    vertexnum=n;
    arcnum=e;
    for(int i=0;i<vertexnum;i++){       字符串与整形相结合存入vertex
        vertex[i]="v";
        vertex[i]+=(i+'0');
    }
    for(int i=0;i<vertexnum;i++)
        for(int j=0;j<vertexnum;j++)
        arc[i][j]=1000;

    int i,j,num;
    for(int k=0;k<arcnum;k++){
        cin>>i>>j>>num;
        arc[i][j]=num;
    }
}
void MGraph::Dijkstra(int v,int x){
    string s[Max];
    string path[Max];
    int dist[Max];
    for(int i=0;i<vertexnum;i++){
        s[i]="";              
        dist[i]=arc[v][i];               //存储相邻点的权值
        if(dist[i]!=Max)
            path[i]=vertex[v]+" "+vertex[i];   // 存储可能的路径
        else
            path[i]="";
    }
    s[v]=vertex[v];                  //存储每条最短最短路径的终点可写成s[0]=vertex[v];
    int num=1;
    while(num<vertexnum){
        int k=0;
        for(int i=0;i<vertexnum;i++)
            if(dist[i]<dist[k]&&s[i]=="") k=i;
        s[k]=vertex[k];                           //s[num++]=vetex[k];
        num++;
        for(int i=0;i<vertexnum;i++)
        if(dist[k]+arc[k][i]<dist[i]){
            dist[i]=dist[k]+arc[k][i];
            path[i]=path[k]+" "+vertex[i];
        }
    }
    if(path[x]!=""){
        cout<<dist[x]<<endl;
        cout<<path[x]<<endl;
    }
    else
        cout<<"no answer"<<endl;
}
int main()
{
    int n,e;
    int v,x;
    cin>>n>>e;
    cin>>v>>x;
    MGraph mg(n,e);
    mg.Dijkstra(v,x);
}

2，floyd算法（任意一对节点之间的最短路径）

邻接矩阵存储，迭代进行

#include<iostream>
#include<vector>
using namespace std;
  int path[99][99];
void judge(int x,int y)
{
     int k=path[x][y];
     if(k==-1) return;
	 judge(x,k);
	 cout<<"v"<<k<<" ";
	 judge(k,y);
}

int main(){
    int n,m,v,e;
    cin>>n>>m>>v>>e;
    int dist[99][99];


    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++){
        dist[i][j]=10000;
		path[i][j]=-1;}

    while(m--){
            int x,y,z;
        cin>>x>>y>>z;
    dist[x][y]=z;
    }

    for(int k=0;k<n;k++)
     for(int j=0;j<n;j++)
        for(int i=0;i<n;i++){
	if(k==j || k==i || i==j) continue;
        if(dist[i][k]+dist[k][j]<dist[i][j]){
            dist[i][j]=dist[i][k]+dist[k][j];
            path[i][j]=k;
        }}
	bool Flag=false;

         if(dist[v][e]!=10000)
		 {
			 Flag=true;
             cout<<dist[v][e]<<endl;
			 cout<<"v"<<v<<" ";
             judge(v,e);
			 cout<<"v"<<e<<" "<<endl;
		 }


   if(Flag==false)
   cout<<"no answer"<<endl;

}

五，有向无环图及其应用。

1，AOV网

在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，称这样的有向图为顶点表示活动的网，简称AOV网。

拓扑序列（前驱后继关系都满足）

若从顶点vi到vj有一条路径，则在顶点的拓扑序列中顶点vi必在顶点vj之前。

拓扑排序：对一个有向图构造拓扑序列的过程称为拓扑排序 。

#include<bits/stdc++.h>
using namespace std;
struct bian{
    int hao;
bian *e;
};
struct dian{
int ru;
int  t;
bian *first;
};
int main(){
int v,a;
cin>>v>>a;
dian dd[v+1];
for(int i=1;i<=v;i++)          //边集数组，单存一个入度
{
    dd[i].ru=0;
    dd[i].t=i;
    dd[i].first=NULL;
}
for(int i=0;i<a;i++)
{
    int x,y;
    bian *s;
    cin>>x>>y;
    dd[y].ru++;
    s=new bian;
    s->hao=y;
    s->e=dd[x].first;
    dd[x].first=s;
}

stack<int>p;                 /用栈进行操作
for(int i=v;i>=1;i--)
    if(dd[i].ru==0)
    p.push(i);
while(!p.empty()){
    int j=p.top();
    p.pop();
    cout<<"v"<<dd[j].t<<" ";
   bian *q;
    q=dd[j].first;
    while(q!=NULL){
        int k=q->hao;
        dd[k].ru--;
        if(dd[k].ru==0)
            p.push(k);
        q=q->e;
    }
}



}

2，AOE网

在一个表示工程的带权有向图中，

用顶点表示事件，

用有向边表示活动，

边上的权值表示活动的持续时间，

称这样的有向图叫做边表示活动的网，简称AOE网。

AOE网中没有入边的顶点称为始点（或源点），没有出边的顶点称为终点（或汇点）。

AOE网的性质：

⑴ 只有在某顶点所代表的事件发生后，从该顶点出发的各活动才能开始；

⑵ 只有在进入某顶点的各活动都结束，该顶点所代表的事件才能发生。

 

 

关键路径：在AOE网中，从始点到终点具有最大路径长度（该路径上的各个活动所持续的时间之和）的路径称为关键路径。

关键活动：关键路径上的活动称为关键活动。

⑴ 事件的最早发生时间ve[k]， 指从始点开始到顶点vk的最大路径长度。这个长度决定了所有从顶点vk发出的活动能够开工的最早时间。

⑵ 事件的最迟发生时间vl[k] ，指在不推迟整个工期的前提下,事件vk允许的最晚发生时间。

⑶ 活动的最早开始时间e[i]

⑷ 活动的最晚开始时间l[i]

#include<bits/stdc++.h>
using namespace std;
struct Edge{                       //构建边的结构体，表式边的俩点，边上事件的最早最晚发生时间
	int from;
	int to;
	int e;
	int l;
};
int ve[99];
int vl[99];

	int vertexnum;
	int adjlist[99][99];   
	int start,end;
	Edge edge[99];  

int main(){
    int v,a;
    int visit[99];
    cin>>v>>a;

    vertexnum=v;


    for(int i=1;i<=v;i++)
        for(int j=1;j<=v;j++)
        adjlist[i][j]=9999;
         for(int i=1;i<=a;i++){
        int x,y,z;
        cin>>x>>y>>z;
        adjlist[x][y]=z;
        edge[i].from=x;
        edge[i].to=y;

    }
    queue<int>q;
    q.push(1);//源点事件入队
	for(int j=1;j<=vertexnum;j++)	{  
		ve[j]=0;	visit[j]=0;	}
	visit[1]=1;
     while(!q.empty())	{
		int i=q.front();       
		q.pop();
		for(int j=1;j<=vertexnum;j++){//计算i的邻接点的ve
			if(adjlist[i][j]!=9999 && ve[i]+adjlist[i][j]>ve[j] ){
				ve[j]=ve[i]+adjlist[i][j];    //算最早，找大的
				if(!visit[j])   
					q.push(j);
				visit[j]=1;
			}
		}
	}
	//for(int i=1;i<=v;i++)
       // cout<<ve[i]<<" ";
    //cout<<endl;
/
      q.push(vertexnum);
	for(int j=1;j<=vertexnum;j++)	{
		vl[j]=ve[vertexnum];	visit[j]=0;	}
    while(!q.empty())	{
		int i=q.front();
		q.pop();
		for(int j=1;j<=vertexnum;j++)	{
			if(adjlist[j][i]!=9999 && vl[i]-adjlist[j][i]<vl[j] ){
				vl[j]=vl[i]-adjlist[j][i];
				if(!visit[j])
					q.push(j);
				visit[j]=1;
			}
		}
	}
	//for(int i=1;i<=v;i++)
      //  cout<<vl[i]<<" ";
    //cout<<endl;
	//

int f=0;
for(int i=1;i<=a;i++)
	{
		edge[i].e=ve[edge[i].from];      //根据节点算边，找相等的是关键路径
		edge[i].l=vl[edge[i].to]-adjlist[edge[i].from][edge[i].to];
		if(edge[i].e==edge[i].l){
                if(f==0){
			cout<<"v"<<edge[i].from<<" "<<"v"<<edge[i].to<<" ";
			f=1;}
			else
                cout<<"v"<<edge[i].to<<" ";
		}

	}
	cout<<endl;
/*for(int i=1;i<=a;i++)
	cout<<edge[i].e<<" ";
	cout<<endl;
	for(int i=1;i<=a;i++)
	cout<<edge[i].l<<" ";*/
}

 

_Violet_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之图---最小生成树Prim算法---C++实现
老夫编代码就是一把梭
08-18 2096
一、需求图Prim算法最小生成树 无向图中点与点之间，边上的数字表示权值。 二、实现Prim算法最小生成树 1.边的描述 定义边的对象时应有以下属性：这条边连接两端的点（nodeIndexA，nodeIndexB），边的权值，以及这条边是否被选中 //Edge.h #ifndef _EDGE_H_ #define _EDGE_H_ class Edge{ public:
数据结构-图
qq_44255741的博客
01-02 739
图1.图的定义2.图的存储2.1邻接矩阵、邻接表法2.1.1邻接矩阵2.1.2邻接表法2.2 邻接多重表、十字链表2.2.1邻接多重表2.2.2十字链表3.图的遍历3.1深度优先遍历DFS3.2广度优先遍历BFS4.图的相关应用4.1最小生成树4.1.1Prim算法4.1.2Kruskal算法4.2最短路径4.2.1迪杰斯特拉（Dijksta）算法4.2.2弗洛伊德（Floyd）算法4.3拓扑排序4.3.1AOV网4.4关键路径4.4.1AOE网 1.图的定义 图是由一个顶点集 V 和一个弧集 R构成的数据
数据结构算法（1） 最小路径
苦逼的小怪兽
11-26 1224
假设这样一个情景： A、B、C、D、E、F五个地方之间的距离为 AB：10  AE：30  AF：100  BC：5  CD：50  DF：10  ED：20  EF：60 求A点到其余各点的最小距离。 可先画出一个带权有向图   首先我有一个最直接的思路，由于在创建图的时候，把不存在的边的权值（即距离）设置为一个较大的数，设为M，那么两个点之间的边数是有限的 比如v0到v1：v0-
c++数据结构之图篇
qq_40420795的博客
09-11 2万+
c++数据结构之图篇 一、图的基本概念与原理 什么是图？ 有向图与无向图； 顶点 弧：弧尾和弧头 度：出度和入度 顶点 边 邻接点 连通图 完全图：边数=n(n-1)/2 生成树：边数=n-1 图的表示法 图的遍历 最小生成树：注意最小生成树的应用 图的应用： 路径规划 工程规划 战略规划 二、图的存储方式 对于无向图：存储顶点及边 对于有向图：存储顶点及弧 ...
数据结构C语言版（答案）
热门推荐
hrdzkj的专栏
09-15 6万+
第1章  绪论 1.1 简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。 解：数据是对客观事物的符号表示。在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。     数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。     数据对象是性质相同的数据元素的集合，是数据的一个子集。     数据结构是相互之间存在
数据结构课程总结.docx
12-17
"数据结构课程总结" 数据结构是计算机科学中的一个基础概念，它是指计算机存储、组织和管理数据的方式。数据结构课程的主要内容包括数组、链表、栈、队列、树、图等基本数据结构，以及排序、搜索、图算法等高级数据...
数据结构考研总结PDF超清
03-11
数据结构基础知识点 数据结构是计算机科学中的一门基础学科，研究的是数据的存储、表示和操作。它是计算机科学与技术的基础知识之一。 一、数据的定义 数据是信息的载体，是描述客观事物属性的数、字符及所有能...
数据结构实验报告总结.doc
12-17
"数据结构实验报告总结" 数据结构实验报告总结是对数据结构课程实验的总结报告，该报告涵盖了数据结构的基础知识、实验过程和结果分析等内容。 知识点： 1. 数据结构基础知识：包括数组、链表、栈、队列、树、图...
数据结构期末复习总结.doc
11-30
以下是对数据结构期末复习内容的详细总结： 1. 数据与数据元素： - 数据是描述现实世界事物的符号集合，包括数值和非数值形式，如数字、字符、图像、音频等。 - 数据元素是数据的基本单位，它可以是一个单一的...
考研408数据结构总结Markdown
03-14
考研408数据结构总结Markdown
Prim算法求最小生成树
Lj135328的博客
12-02 919
Prim算法基本思想 设G＝（V，E）是无向连通网，T＝(U,TE）是G的最小生成树，Prim算法的基本思想是:从初始状态U＝｛v｝（v∈V）、TE＝{ }开始，重复执行下述操作:在所有i∈U,j∈V-U的边中找一条代价小的边（i,j）并人集合TE，同时j并入U，直至U＝V为止，此时TE中有n-1条边，T是一棵最小生成树。 简单来说，Prim算法就是在不产生回路的前提下，从任意结点开始...
数据结构（C++）Prime算法
qq_43656233的博客
11-21 5271
Prime和Kruskal两种算法是求图最小生成树的两种算法，Prime是找点，Kruskal是找边，各有各的有点，也其实都有点小难。 最小生成树的点数等于原先图的点数，边数等于点数-1 。 使用邻接矩阵，关于图的数组存储之前就已经写过了点击这里 图数组存储的构造函数 依然保持着自己的习惯，每个顶点都从1开始计算，不从0，方便输入。 比之前的构造函数增加了边权，如果没有赋权则为INF（无穷大）。 ...
[数据结构笔记] 图
SegmentationFault
11-24 320
图的逻辑结构 图的定义 图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为： G=(V，E) 其中：G表示一个图，V是图G中顶点的集合，E是图G中顶点之间边的集合。 在线性表中，元素个数可以为零，称为空表； 在树中，结点个数可以为零，称为空树； 在图中，顶点个数不能为零，但可以没有边。 图的基本术语 简单图：在图中，...
Prim算法（普里姆算法）加点法-Prim算法
梦想之深邃
12-17 973
数据结构实验之图论六：村村通公路 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Discuss Problem Description 当前农村公路建设正如火如荼的展开，某乡镇政府决定实现村村通公路，工程师现有各个村落之间的原始道路统计数据表，表中列出了各村之间可以建设公路的若干条道路的成本，你的任务是
最小生成树算法：Prim、Kruskal
Chen Rong的博客
09-11 252
Prim算法实现完整代码： #include&amp;lt;iostream&amp;gt; using namespace std; const int Max=100; class MGraph{ public: MGraph(){ } MGraph(int n,int e); ~MGraph(){ } ...
数据结构-图-知识点总结
Ontheroad_的博客
05-25 4万+
一、基本术语 图（graph）：图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V是图G中的顶点的集合，E是图G中边的集合。 顶点(Vertex)：图中的数据元素。线性表中我们把数据元素叫元素，树中将数据元素叫结点。 边：顶点之间的逻辑关系用边来表示，边集可以是空的。 无向边(Edge)：若顶点V1到V2之间的边没有方向，则称这条边为无向边。
数据结构——Prim算法
qq_43627106的博客
12-02 555
基本思想：（加点） 设G=(V, E)是具有n个顶点的连通网， T=(U, TE)是G的最小生成树， T的初始状态为U={u0}（u0∈V），TE={ }， 重复执行下述操作： 在所有u∈U，v∈V-U的边中找一条代价最小的边(u, v)并入集合TE，同时v并入U，直至U=V。 伪代码： 算法：Prim 输入：无向连通网G=(V,E) 输出：最小生成树T=(U,TE) 1. 初始化两个辅助数组lo...
数据结构--图总结（八大算法）
qq_41409979的博客
05-12 2304
图总结 本章主要讲诉一些图的经典算法以及容易忘记的概念便于以后进行复习。 文章目录图总结一、易混淆的概念二、经典算法1.DFS与BFS2.读入数据总结 一、易混淆的概念 边，弧：顶点到顶点之间有向叫做边，无向叫做弧。 完全图,连通图：任意两个顶点之间都有边是完全图，任意两个顶点之间存在路劲是连通图（如果是有向的话叫强连通图）。 生成树,有向树,生成深林：无向联通图中如果只有n个顶点n-1条边（没有环）叫生成树，有向图中只有一个顶点入度为0，其余顶点入度为1叫做有向树。一个有向图由若干个有向树构成生成深林
数据结构的图总结与讨论
最新发布
05-29
input keyevent 67好的，关于数据结构中的图，我们可以总结如下： 1. 定义：图是由节点和; sleep 1; input keyevent 67; sleep 1; input keyevent 67; sleep 1; input keyevent 边组成的一种非线性数据结构。节点...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值