有向图转换&遍历&拓扑&最短路径

最新推荐文章于 2024-07-06 16:15:01 发布
最新推荐文章于 2024-07-06 16:15:01 发布
阅读量982 收藏
点赞数
文章标签： struct null path 算法 system fp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzy5177/article/details/6475719
版权

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#define MaxStr 20
typedef int Status;
typedef int ElemType;
typedef struct{    
    ElemType VNode;
    int indgree;
    }VexType;
typedef struct Arc{
    VexType Adj;
    unsigned int Weight;
    struct Arc *NextArc;
    }ArcType;
typedef struct{                                    
    VexType *Vex;
    ArcType **FirstArc;                  //邻接表;
//    ArcType **InvertArc;               //逆邻接表;
    int VexNums;                         //顶点总数;
    }DLGraph;                            //图的邻接表结构定义;
typedef struct{
    ElemType *Vex;
    unsigned int **Arc;                                
    int VexNums;
    }DMGraph;                            //图的邻接矩阵结构定义;
//========================================================================================
Status CreateDMGraph(DMGraph *DMG);            //创建图的邻接矩阵;
Status DMG_Traver(DMGraph DMG);                //邻接矩阵的遍历;
Status DMG_DFS(DMGraph DMG,int v,int *Visited);      //邻接矩阵深度遍历(递  归);
Status DMG_DFS_Uni(DMGraph DMG,int v,int *Visited);  //邻接矩阵深度遍历(非递归);
Status DMG_BFS(DMGraph DMG,int v,int *Visited);      //邻接矩阵广度遍历;
Status DMG2DLG(DMGraph DMG,DLGraph *DLG);      //邻接矩阵转换为邻接表;
Status DLG_Traver(DLGraph DLG);                //邻 接 表的遍历;
Status DLG_DFS(DLGraph DLG,int v,int *Visited);      //邻 接 表深度遍历(递  归);
Status DLG_DFS_Uni(DLGraph DLG,int v,int *Visited);  //邻 接 表深度遍历(非递归);
Status DLG_BFS(DLGraph DLG,int v,int *Visited);      //邻 接 表广度遍历;
//---------------------------------------------------------
Status Topsort(DLGraph DLG,ElemType **ts);        //邻接表有向图的Topsort;
Status Dijkstra(DMGraph DMG,ElemType v,unsigned int *dist);//Dijkstra;
Status PRN_DK(DMGraph DMG,unsigned int ***dis);        //输出Dijkstra算法;
Status Floyd(DMGraph DMG,unsigned int ***flyd);        //Floyd;
Status PRN_DMGraph(DMGraph DMG);            //输出邻接矩阵;
Status PRN_DLGraph(DLGraph DLG);            //输出邻接表;
//========================================================================================
int main(void)
{
    int i,j;
    DMGraph DMG;    
    DLGraph DLG;
    ElemType *ts;
    unsigned int **dist,**flyd;
    printf(    " 一、创立有向图的邻接矩阵：/n");    
        CreateDMGraph(&DMG);
        PRN_DMGraph(DMG);
    printf("/n/n 二、有向图-邻接矩阵的遍历：/n");
        DMG_Traver(DMG);
    printf("/n/n 三、邻接矩阵转换为邻接表：/n");
        DMG2DLG(DMG,&DLG);    
        PRN_DLGraph(DLG);
    printf("/n/n 四、有向图-邻接表的遍历：/n");
        DLG_Traver(DLG);
    printf("/n/n 五、邻接表有向图的拓扑排序：/n");
        Topsort(DLG,&ts);
    printf("/n/n/n");system("pause");
    printf("/n/n 六、邻接矩阵有向图的各点最短路径：/n/n  1. Dijkstra(迪杰斯特拉算法):");
        PRN_DK(DMG,&dist);
    printf("/n/n/n  2. Floyd(弗洛伊德算法):");
        Floyd(DMG,&flyd);

    printf("/n");    system("pause");
    printf("/n/n/nDijkstra最短路径测试输出：/n 某两点 ： 最短路径");
    for(i = 1;i <= DMG.VexNums;i++)
        for(j = 1;j <= DMG.VexNums;j++)
            if(dist[i][j] < INT_MAX) printf("/n[%2d,%2d] : %5d ",i,j,dist[i][j]);
    printf("/n/nFloyd最短路径测试输出：/n 某两点 ： 最短路径");
    for(i = 1;i <= DMG.VexNums;i++)
        for(j = 1;j <= DMG.VexNums;j++)
            if(flyd[i][j] < INT_MAX) printf("/n[%2d,%2d] : %5d ",i,j,flyd[i][j]);
    printf("/n");    system("pause");
    return 0;
}

 

Status CreateDMGraph(DMGraph *DMG)        //创建图的邻接矩阵;
{
    char ReadFileName[MaxStr];
    unsigned int w;
    FILE *fp;
    int i,j;
    do{
        printf("/n     输入文本文件名：");
        gets(ReadFileName);
    }while(ReadFileName[0] == '/0' || !(fp = fopen(ReadFileName,"r")));

    fscanf(fp,"%d",&DMG->VexNums);        //得到顶点总数;
    if(!(DMG->Vex = (ElemType *)malloc((DMG->VexNums+1)*sizeof(ElemType))))
        {printf("/n内存溢出。");return 1;}
    if(!(DMG->Arc = (unsigned int **)malloc((DMG->VexNums+1)*sizeof(unsigned int*))))
        {printf("/n内存溢出。");return 1;}
    for(i = 1;i <= DMG->VexNums;i++)    //邻接矩阵初始化;
    {
        DMG->Vex[i] = i;        //
        if(!(DMG->Arc[i]=(unsigned int *)malloc((DMG->VexNums+1)*sizeof(unsigned int))))
            {printf("/n内存溢出。");return 1;}
        for(j = 1;j <= DMG->VexNums;j++)
        {
            DMG->Arc[i][j] = INT_MAX;
        }
    }
    while(fscanf(fp,"%d%d%u",&i,&j,&w) == 3)    DMG->Arc[i][j] = w;//
    fclose(fp);
    return 0;
}
//========================================================================================
Status DMG2DLG(DMGraph DMG,DLGraph *DLG)    //图的邻接矩阵转换为邻接表;
{
    int i,j;
    ArcType *p = NULL;
    DLG->VexNums = DMG.VexNums;
    if(!(DLG->Vex = (VexType *)malloc((DLG->VexNums+1)*sizeof(VexType))))
        {printf("/n内存溢出。");return 1;}
    if(!(DLG->FirstArc = (ArcType **)malloc((DLG->VexNums+1)*sizeof(ArcType*))))
        {printf("/n内存溢出。");return 1;}
    for(i = 1;i <= DLG->VexNums;i++)
    {
        DLG->Vex[i].VNode = DMG.Vex[i];    //
        DLG->FirstArc[i] = NULL;
        DLG->Vex[i].indgree = 0;
        for(j = 1;j <= DMG.VexNums;j++)
        {
            if(DMG.Arc[i][j] < INT_MAX)
            {
                if(!(p = (ArcType *)malloc(sizeof(ArcType))))
                    {printf("/n内存溢出。");return 1;}
                p->Adj.VNode = DMG.Vex[j];
                p->Weight = DMG.Arc[i][j];
                p->NextArc = DLG->FirstArc[i];
                DLG->FirstArc[i] = p;
            }
        }
        for(j = 1;j <= DMG.VexNums;j++)
        {
            if(DMG.Arc[j][i] < INT_MAX)    ++DLG->Vex[i].indgree;
        }
    }
    return 0;
}
//========================================================================================
Status DMG_Traver(DMGraph DMG)    //邻接矩阵的遍历;
{
    int i,*Visited;
    if(!(Visited = (int *)malloc((DMG.VexNums+1)*sizeof(int))))
        {printf("/n内存溢出。");return 1;}    
    printf("/n  1. 图的深度遍历：/n递  归：");    
    for(i = 1;i <= DMG.VexNums;i++)        Visited[i] = 0;    
    for(i = 1;i <= DMG.VexNums;i++)        
        if(Visited[i] == 0)        DMG_DFS(DMG,i,Visited);
    printf("/n非递归：");
    for(i = 1;i <= DMG.VexNums;i++)        Visited[i] = 0;
    for(i = 1;i <= DMG.VexNums;i++)
        if(Visited[i] == 0)        DMG_DFS_Uni(DMG,i,Visited);
    printf("/n/n  2. 图的广度遍历：/n/t");    
    for(i = 1;i <= DMG.VexNums;i++)        Visited[i] = 0;
    for(i = 1;i <= DMG.VexNums;i++)
        if(Visited[i] == 0)        DMG_BFS(DMG,i,Visited);
    return 0;
}
//========================================================================================
Status DLG_Traver(DLGraph DLG)    //邻 接 表的遍历;
{
    int i,*Visited;
    if(!(Visited = (int *)malloc((DLG.VexNums+1)*sizeof(int))))
        {printf("/n内存溢出。");return 1;}    
    printf("/n  1. 图的深度遍历：/n递  归：");    
    for(i = 1;i <= DLG.VexNums;i++)        Visited[i] = 0;
    for(i = 1;i <= DLG.VexNums;i++)
        if(Visited[i] == 0)        DLG_DFS(DLG,i,Visited);
    printf("/n非递归：");
    for(i = 1;i <= DLG.VexNums;i++)        Visited[i] = 0;
    for(i = 1;i <= DLG.VexNums;i++)
        if(Visited[i] == 0)        DLG_DFS_Uni(DLG,i,Visited);
    printf("/n/n  2. 图的广度遍历：/n/t");    
    for(i = 1;i <= DLG.VexNums;i++)        Visited[i] = 0;
    for(i = 1;i <= DLG.VexNums;i++)
        if(Visited[i] == 0)        DLG_BFS(DLG,i,Visited);
    printf("/n");
    return 0;
}
//========================================================================================
Status DMG_DFS(DMGraph DMG,int v,int *Visited)    //邻接矩阵深度遍历(递  归);
{
    int i;
    Visited[v] = 1;
    printf("%2d ->",v);
    for(i = 1;i <= DMG.VexNums;i++)
        if(Visited[i] == 0 && DMG.Arc[v][i] < INT_MAX)
            DMG_DFS(DMG,i,Visited);
    return 0;
}
//========================================================================================
Status DLG_DFS(DLGraph DLG,int v,int *Visited)    //邻 接 表深度遍历(递  归);
{
    ArcType *p = NULL;
    Visited[v] = 1;
    printf("%2d ->",v);
    p = DLG.FirstArc[v];
    while(p != NULL)
    {
        if(Visited[p->Adj.VNode] == 0)    DLG_DFS(DLG,p->Adj.VNode,Visited);
        p = p->NextArc;
    }
    return 0;
}
//========================================================================================
Status DMG_DFS_Uni(DMGraph DMG,int v,int *Visited)    //邻接矩阵深度遍历(非递归);
{
    int i,*Stack,top = -1;
    if(!(Stack = (int *)malloc((DMG.VexNums+1)*sizeof(int))))
        {printf("/n内存溢出。");return 1;}
    Visited[v] = 1;
    printf("%2d ->",v);
    Stack[++top] = v;
    while(top != -1)
    {
        for(i = 1;i <= DMG.VexNums;i++)
            if(Visited[i] == 0 && DMG.Arc[Stack[top]][i] < INT_MAX)
            {
                Visited[i] = 1;
                printf("%2d ->",i);
                Stack[++top] = i;
                break;
            }
        if(i == DMG.VexNums+1)    --top;
    }
    return 0;
}
//========================================================================================
Status DLG_DFS_Uni(DLGraph DLG,int v,int *Visited)    //邻 接 表深度遍历(非递归);
{
    int *Stack,top = -1;
    ArcType *p = NULL;
    if(!(Stack = (int *)malloc((DLG.VexNums+1)*sizeof(int))))
        {printf("/n内存溢出。");return 1;}
    Visited[v] = 1;
    printf("%2d ->",v);
    Stack[++top] = v;
    while(top != -1)
    {
        p = DLG.FirstArc[Stack[top]];
        while(p != NULL)
        {
            if(Visited[p->Adj.VNode] == 0)
            {
            Visited[p->Adj.VNode] = 1;
            printf("%2d ->",p->Adj.VNode);
            Stack[++top] = p->Adj.VNode;
            break;
            }
            p = p->NextArc;
        }
        if(p == NULL)    --top;
    }
    return 0;
}
//========================================================================================
Status DMG_BFS(DMGraph DMG,int v,int *Visited)    //邻接矩阵广度遍历;
{
    int i,*Queue,rear,front;
    if(!(Queue = (int *)malloc((DMG.VexNums+1)*sizeof(int))))
        {printf("/n内存溢出。");return 1;}
    Visited[v] = 1;
    printf("%2d ->",v);
    rear = front = 0;
    rear = (rear+1)%DMG.VexNums;
    Queue[rear] = v;
    while(rear != front)
    {
        front = (front+1)%DMG.VexNums;
        for(i = 1;i <= DMG.VexNums;i++)
            if(Visited[i] == 0 && DMG.Arc[Queue[front]][i] < INT_MAX)
            {
                Visited[i] = 1;
                printf("%2d ->",i);
                rear = (rear+1)%DMG.VexNums;
                Queue[rear] = i;
            }
    }
    return 0;
}
//========================================================================================
Status DLG_BFS(DLGraph DLG,int v,int *Visited)    //邻 接 表广度遍历;
{
    ArcType *p = NULL;
    int *Queue,rear,front;
    if(!(Queue = (int *)malloc((DLG.VexNums+1)*sizeof(int))))
        {printf("/n内存溢出。");return 1;}
    rear = front = 0;
    Visited[v] = 1;
    printf("%2d ->",v);
    rear = (rear+1)%DLG.VexNums;
    Queue[rear] = v;
    while(rear != front)
    {
        front = (front+1)%DLG.VexNums;
        p = DLG.FirstArc[Queue[front]];
        while(p != NULL)
        {
            if(Visited[p->Adj.VNode] == 0)
            {
                Visited[p->Adj.VNode] = 1;
                printf("%2d ->",p->Adj);
                rear = (rear+1)%DLG.VexNums;
                Queue[rear] = p->Adj.VNode;
            }
            p = p->NextArc;
        }
    }
    return 0;
}
//========================================================================================
Status Topsort(DLGraph DLG,ElemType **ts)    //邻接表有向图的Topsort拓扑排序;
{
    int i,j,k,m = 0,top = -1;
    ArcType *tp,*p;
    if(!(*ts = (ElemType *)malloc((DLG.VexNums+1)*sizeof(ElemType))))
        {printf("/n内存溢出。");return 1;}
    if(!(tp = (ArcType *)malloc((DLG.VexNums+1)*sizeof(ArcType))))
        {printf("/n内存溢出。");return 1;}
    printf("   Topsort：/n/n   ");
    for(i = 1;i <= DLG.VexNums;i++)            //初始化tp;
    {
        tp[i].Adj.VNode = DLG.Vex[i].VNode;
        tp[i].NextArc = DLG.FirstArc[i];
        tp[i].Adj.indgree = DLG.Vex[i].indgree;
        if(DLG.Vex[i].indgree == 0)
        {
            tp[i].Adj.indgree = top;
            top = i;
        }
    }
    while(top != -1)
    {
        j = top;
        top = tp[top].Adj.indgree;
        printf(" %2d ,",tp[j].Adj.VNode);
        ++m;
        p = tp[j].NextArc;
        while(p != NULL)
        {
            k = p->Adj.VNode;
            --tp[k].Adj.indgree;
            if(tp[k].Adj.indgree == 0)
            {
                tp[k].Adj.indgree = top;
                top = k;
            }
            p = p->NextArc;
        }
    }
    if(m < DLG.VexNums)    printf("/n不能拓扑!/n");
    return 0;
}
//========================================================================================
Status PRN_DK(DMGraph DMG,unsigned int ***dis)        //输出Dijkstra最短路径;
{
    int i,j,flag;
    unsigned int **dist;
    if(!(dist = (unsigned int **)malloc((DMG.VexNums+1)*sizeof(unsigned int*))))
        {printf("/n内存溢出。");return 1;}
    *dis = dist;
    for(i = 1;i <= DMG.VexNums;i++)
    {
        if(!(dist[i] = (unsigned int *)malloc((DMG.VexNums+1)*sizeof(unsigned int))))
            {printf("/n内存溢出。");return 1;}
        Dijkstra(DMG,i,dist[i]);    //Dijkstra最短路径;
    }
    for(i = 1;i <= DMG.VexNums;i++)
    {
        flag = 0;
        printf("/n从%3d出发的最短路径：",i);
        for(j = 1;j <= DMG.VexNums;j++)
        {
            if(j != i && dist[i][j] < INT_MAX)
            {
                printf("/n/t自%3d ==>%3d点：%4d",i,j,dist[i][j]);
                flag = 1;
//if(j != i && dist[i][j] == INT_MAX)        printf("/n/t自%3d ==>%3d点：  ∞",i,j);
//else if(j == i);printf("/n/t自%3d ==>%3d点：%4d",i,j,dist[i][j]);
            }
        }
        if(flag == 0)    printf("/n/t没有任何路径...555555");    
    }
    return 0;
}
//========================================================================================
Status Dijkstra(DMGraph DMG,ElemType v,unsigned int *dist)//最短路径Dijkstra(迪杰斯特拉);
{
    int i,j,t;
    ElemType *flag;
    unsigned int min;    
    if(!(flag = (ElemType *)malloc((DMG.VexNums+1)*sizeof(ElemType))))
        {printf("/n内存溢出。");return 1;}
    for(i = 1;i <= DMG.VexNums;i++)        //初始化,置U={v}到V-U到各点最短路径;
    {
        flag[i] = 0;
        dist[i] = DMG.Arc[v][i];
    }
    flag[v] = 1;                //v并入U;
    for(i = 1;i <= DMG.VexNums;i++)                
    {
        min = INT_MAX;
        t = i;
        for(j = 1;j <= DMG.VexNums;j++)    //找到U到V-U最小权值(最短路径);
        {
            if(flag[j] == 0 && min > dist[j])
            {
                min = dist[j];
                t = j;
            }
        }
        flag[t] = 1;            //t并入U;
        for(j = 1;j <= DMG.VexNums;j++)    //重置U到V-U各点最短路径;
        {
            if(flag[j] == 0 && dist[t] + DMG.Arc[t][j] < dist[j])
            {
                dist[j] = dist[t] + DMG.Arc[t][j];
            }
        }
    }
    return 0;
}
//========================================================================================
Status Floyd(DMGraph DMG,unsigned int ***flyd)    //Floyd(弗洛伊德)最短路径;
{                                                        int i,j,k,**Path = NULL;
    unsigned int **Weight = NULL;
    if(!(Path = (int **)malloc((DMG.VexNums+1)*sizeof(int*))))
        {printf("/n内存溢出。");return 1;}
    if(!(Weight = (unsigned int **)malloc((DMG.VexNums+1)*sizeof(unsigned int*))))
        {printf("/n内存溢出。");return 1;}
    *flyd = Weight;
    for(i = 1;i <= DMG.VexNums;i++)        //初始化;
    {
        if(!(Path[i] = (int *)malloc((DMG.VexNums+1)*sizeof(int))))
            {printf("/n内存溢出。");return 1;}
        if(!(Weight[i] = (unsigned int *)malloc((DMG.VexNums+1)*sizeof(unsigned int))))
            {printf("/n内存溢出。");return 1;}
        for(j = 1;j <= DMG.VexNums;j++)
        {
            Weight[i][j] = DMG.Arc[i][j];
            Path[i][j] = 0;
        }
    }
    for(k = 1;k <= DMG.VexNums;k++)        //Floyd迭代算法;
        for(i = 1;i <= DMG.VexNums;i++)
            for(j = 1;j <= DMG.VexNums;j++)
                if(Weight[i][j] > (Weight[i][k] + Weight[k][j]))
                {
                    Weight[i][j] = Weight[i][k] + Weight[k][j];
                    Path[i][j] = k;
                }
    for(i = 1;i <= DMG.VexNums;i++)        //输出;
    {
        printf("/n从%3d出发的最短路径：",i);
        for(j = 1;j <= DMG.VexNums;j++)
        {
            if(j != i && Weight[i][j] < INT_MAX)
                printf("/n/t自%3d ==>%3d点：%4d",i,j,Weight[i][j]);
        }
    }
    return 0;
}
//========================================================================================
Status PRN_DMGraph(DMGraph DMG)        //输出邻接矩阵;
{
    int i,j;
    for(i = 1;i <= DMG.VexNums;i++)
    {
        printf("/n/t");
        for(j = 1;j <= DMG.VexNums;j++)
        {
            if(DMG.Arc[i][j] < INT_MAX)    printf(" %3d ",DMG.Arc[i][j]);
            else printf("  ∞ ");
        }                                    
        printf("/n");
    }
    return 0;
}
//========================================================================================
Status PRN_DLGraph(DLGraph DLG)        //输出邻接表;
{
    int i;
    ArcType *p = NULL;
    for(i = 1;i <= DLG.VexNums;i++)
    {
        printf("/n %2d(入度%2d) ==>  ",i,DLG.Vex[i].indgree);
        p = DLG.FirstArc[i];
        while(p != NULL)
        {
            if(p->NextArc)    printf("%2d(%3d) ->",p->Adj.VNode,p->Weight);
            else printf("%2d(%3d) 。",p->Adj.VNode,p->Weight);
            p = p->NextArc;
        }
    }
    return 0;
}

zzy5177
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
[图] 拓扑排序 拓扑有序序列-有向图是否有回路-AOV网络
geodoer
08-12 2万+
背景 用【有向图】表示一个【工程的施工图】或【程序的数据流图】，则图中不允许出现回路 例子： 【回路】 打地基-&amp;amp;amp;amp;amp;amp;gt;做房子结构-&amp;amp;amp;amp;amp;amp;gt;砌墙-&amp;amp;amp;amp;amp;amp;gt;装修-&amp;amp;amp;amp;amp;amp;gt;打地基 【解释】 “做房子结构“的前提是“打地基”，“砌墙”的前提是“做房子结构”，“装修”的前提是“砌墙”，“打地基”的前提是“装
有向图中的所有环--深度遍历暴力求解
热门推荐
zhangruijerry的博客
04-05 1万+
华为软件精英挑战赛2020题目 暴力求解了一下，方便理解题目。。。 每个点都进行深度遍历，找到以这个点为起点的环。。。数据再大一点应该就不行了。。。 代码写得烂，仅供参考。。 #include "bits/stdc++.h" using namespace std; void dfs(const vector<vector<int>> &amp;g...
数据结构与算法--图的应用拓扑排序 & 关键路径
LiangliangSpeak的博客
05-19 375
数据结构与算法--图的应用拓扑排序 &amp; 关键路径1. 拓扑排序2. 关键路径 1. 拓扑排序 拓扑排序简介 假设在如下面的一张 有向图 中，顶点表示活动，弧表示活动之间的优先关系，这样的 有向图 顶点表示活动网，我们称之为 AOV 网。   上面 AOV 网的路径为：V1 -> V2 -> V3 -> V4 -> V5 或者 V1 -> V2 -> V3 -> V4 -> V5 设 G = （V，E）是一个具有 n个 顶点的 有向图，V 中
图的遍历——拓扑排序
我曾将青春翻涌成她 也曾指尖码出盛夏
11-10 430
背景知识 拓扑排序就是对有向无环图，将所有顶点排成一个线性序列，该序列满足：如果图里有边&amp;amp;lt;u,v&amp;amp;gt;&amp;amp;lt;u,v&amp;amp;gt;&amp;lt;u,v&amp;gt;，那么在该序列里，u一定要在v前面 算法思想 找到入度为0的点（有向无环图中必定存在！），挨个输出（可能不止一个） 删除这些入度为0的点，并且删除以这些点为起点的边 这样又会出现新的一波入度为0点，输出！ 然后...
经纬度转换&amp;测距（企业内部使用工具）
06-19
该资源为经纬度转换&amp;测距，可以随意切换不同方案，包含了最少时间、最短距离，避开高速等不同方案下的结果。具有可视化的界面，属于一个小程序。 适合物流运营相关的人员或者是在研究路径规划领域的同学进行下载...
ATMEGA64&amp;128最小系统原理图.zip
02-19
这可能是一个直流稳压器或者开关电源，将输入电压转换为微控制器所需的电压等级（通常为5V或3.3V）。 3. **时钟源**：微控制器需要一个时钟信号来同步其操作。这通常是一个石英晶体振荡器（XTAL）或陶瓷谐振器（CR...
VMWAREESX&amp;ESXIIntel网卡兼容性列表.pdf
05-06
VMWAREESX&amp;ESXIIntel网卡兼容性列表.pdfVMWAREESX&amp;ESXIIntel网卡兼容性列表.pdfVMWAREESX&amp;ESXIIntel网卡兼容性列表.pdfVMWAREESX&amp;ESXIIntel网卡兼容性列表.pdfVMWAREESX&amp;ESXIIntel网卡兼容性...
MATLAB&amp;EXCEL工程计算(2).pdf
04-15
MATLAB&amp;EXCEL工程计算(2).pdf
算法训练营day70
stmfresher的博客
07-06 100
三种情况：入度为2的时候，有两种情况一种是删哪个都行，另一种是删掉之后可能出现环，这时候就要判断删除这个边，是否成环了。如果没有入度为2，就是成环，这个从前向后遍历，通过查并集删除删除连通的即可。
[Leetcode 136][Easy]-只出现一次的数字
2201_75413354的博客
07-03 169
②后面研究，发现对于对于查找数组中唯一一个出现一次的元素，我们更适合使用线性扫描和位操作的方法。异或运算满足交换律，且一个数异或自己结果是0，一个数异或0结果是自己。因此把数组中所有元素进行异或运算，得到结果是唯一数。①首先看到数组中重复的数字，想到快慢指针，但是数组的元素是乱序的不好求。使用了STL库的sort函数，时间复杂度O(nlogn)不符合题目要求，空间复杂度O(1)。
C语言 | Leetcode C语言题解之第218题天际线问题
m0_59237910的博客
07-06 134
C语言 | Leetcode C语言题解之第218题天际线问题
69. x 的平方根（简单）
用魔法打败魔法，走楼梯啊！
07-01 917
对于此题，是计算算术平方根的整数部分，因此等价于寻找首次平方之和大于x的数，该数减1即为x的算术平方根（假定x的算术平方根为y.z,其中y为整数部分，z为小数部分，y*y的结果是小于x，而(y+1）*(y+1)是大于x的）。不能使用系统内置的函数，寻找某个数（假定为x）的算术平方根，并返回算术平方根的整数部分，最直观的方法是从0依次开始尝试所有小于等于x的数（假定为y），当y*y的积小于等于x时，继续遍历下一个数，直至y*y的积首次大于x时，此时y-1即为x的算术平方根的整数部分，如。
LSH算法：高效相似性搜索的原理与Python实现II
uncle_ll的博客
07-02 886
lsh基于随机平面的实现
详解反向传播（BP）算法
PiggyRuns的博客
07-02 1184
一文详解反向传播算法公式推导以及pytorch实现
每周算法：无向图的双连通分量
少儿编程乔老师
07-06 617
通过Tarjan算法求无向连通图的双连通分量，计算至少添加多少条边可以将原图变为一个双连通分量。
leetcode77.组合
欢迎来到我的博客~
07-03 165
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。你可以按 任何顺序 返回答案。
Python123:计算天数、查找指定字符、字符串逆序（C语言）
chat8052的博客
07-02 796
Python123:计算天数、查找指定字符、字符串逆序（C语言）
【算法笔记自学】第 5 章 入门篇（3）——数学问题
最新发布
qq_62704693的博客
07-06 147
【代码】【算法笔记自学】入门篇（3）——数学问题。
&amp;和&amp;&amp;的区别 java
03-16
&amp;是HTML中的转义字符，表示“&amp;”符号，而&amp;&amp;是Java中的逻辑运算符，表示“与”的意思。在Java中，&amp;&amp;用于判断两个条件是否同时成立，如果两个条件都为真，则返回true，否则返回false。而&amp;则用于HTML中的标记...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值