dijkstra的算法运行时间与数组和优先级队列

Question

我很难理解dijkstra算法的时间。下面我把我正在分析的伪代码放到数组中。考虑到V是顶点而E是边缘。作为数组的Q初始化时间为O（V），最小值和内部时间为O（V）而O（V + E），则结果为O（V²），am我纠正了吗？

 1  function Dijkstra(Graph, source):
    2      dist[source] ← 0                                    // Initialization
    3
    4      create vertex set Q
    5
    6      for each vertex v in Graph:           
    7          if v ≠ source
    8              dist[v] ← INFINITY                          // Unknown distance from source to v
    9              prev[v] ← UNDEFINED                         // Predecessor of v
    10
    11         Q.add_with_priority(v, dist[v])
    12
    13
    14     while Q is not empty:                              // The main loop
    15         u ← Q.extract_min()                            // Remove and return best vertex
    16         for each neighbor v of u:                      // only v that is still in Q
    17             alt ← dist[u] + length(u, v) 
    18             if alt < dist[v]
    19                 dist[v] ← alt
    20                 prev[v] ← u
    21                 Q.decrease_priority(v, alt)
    22
    23     return dist[], prev[] 

下面我把我正在分析的伪代码放入优先级队列。现在，Q作为优先级队列的初始化时间为O（V），最小值和for内部的时间将为O（V）而O（1 + ElogV），则结果为O（VElogV） ）， 我对么？考虑到最坏的情况是E =（V-1），那么结果不能是O（V²logV），为什么我在网上找到的值是O（ElogV）？为什么优先级队列比数组快？

     1  function Dijkstra(Graph, source):
     2
     3      create vertex set Q
     4
     5      for each vertex v in Graph:             // Initialization
     6          dist[v] ← INFINITY                  // Unknown distance from source to v
     7          prev[v] ← UNDEFINED                 // Previous node in optimal path from source
     8          add v to Q                          // All nodes initially in Q (unvisited nodes)
     9
    10      dist[source] ← 0                        // Distance from source to source
    11      
    12      while Q is not empty:
    13          u ← vertex in Q with min dist[u]    // Node with the least distance
    14                                                      // will be selected first
    15          remove u from Q 
    16          
    17          for each neighbor v of u:           // where v is still in Q.
    18              alt ← dist[u] + length(u, v)
    19              if alt < dist[v]:               // A shorter path to v has been found
    20                  dist[v] ← alt 
    21                  prev[v] ← u 
    22
    23      return dist[], prev[]