迪杰斯特拉算法——堆优化

最新推荐文章于 2025-06-06 09:06:11 发布

TC_Ning

最新推荐文章于 2025-06-06 09:06:11 发布

阅读量558

点赞数 2

CC 4.0 BY-SA版权

分类专栏：数据结构文章标签：算法图论

本文链接：https://blog.youkuaiyun.com/TC_Ning/article/details/109752681

数据结构专栏收录该内容

4 篇文章

订阅专栏

博客提及数据结构实验课的题目，要用堆实现的优先级队列对Dijkstra算法进行优化，还表示若有错误欢迎指正，聚焦于算法优化相关信息技术内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数据结构实验课遇到的题目
要求用堆实现的优先级队列对Djkstra算法进行优化
如有错误还请指正

typedef struct graph
{
    int vernum;
    int vertex[MAX];
    int edge[MAX][MAX];
}GRAPH;
typedef struct
{
    int dst;
    int i;
}NODE;
typedef struct heap
{
    NODE vertex[MAX];
    int n;
}HEAP;
int Dijkstra_heap(GRAPH G,HEAP &heap)
{
    int n;
    printf("\nSet a veretex as source:");
    scanf("%d",&n);
    for(int i=0;i<G.vernum;i++)
    {
        pre[i]=n;
        flag[i]=0;
        dst[i]=G.edge[n][i];
    }
    dst[n]=0;
    flag[n]=1;
    NODE node;
    for(int i=0;i<G.vernum;i++)
    {
        node.dst=dst[i];
        node.i=i;
        Insert(heap,node);
    }
    while(heap.n>0)
    {
        NODE temp=DeleteMin(heap);
        int v=temp.i;
        int dis=temp.dst;
        flag[v]=1;
        for(int k=0;k<G.vernum;k++)
        {
            if(flag[k]==0&&G.edge[v][k]<inf)
            {
                if(dst[v]+G.edge[v][k]<dst[k])
                {
                    dst[k]=dst[v]+G.edge[v][k];
                    pre[k]=v;
                }
            }
        }
    }
    return n;
}
void Insert(HEAP &heap,NODE item)
{
    int i;
    if(heap.n<MAX-1)
    {
        i=heap.n+1;
        while(i!=1&&item.dst<heap.vertex[i/2].dst)
        {
            heap.vertex[i]=heap.vertex[i/2];
            i/=2;
        }
        heap.vertex[i]=item;
        heap.n++;
    }
}
NODE DeleteMin(HEAP &heap)
{
    int parent=1,child=2;
    NODE item,temp;
    if(heap.n>0)
    {
        item=heap.vertex[1];
        temp=heap.vertex[heap.n--];
        while(child<=heap.n)
        {
            if((child<heap.n)&&(heap.vertex[child].dst>heap.vertex[child+1].dst))
                child++;
            if(temp.dst<=heap.vertex[child].dst) break;
            heap.vertex[parent]=heap.vertex[child];
            parent=child;
            child*=2;
        }
        heap.vertex[parent]=temp;
        return item;
    }
}