Kruskal's and Prim's Algorithms are two important ways to find the Minimum Spanning Tree (MST) in a graph. They work in different ways and have different speeds.

Kruskal's Algorithm is great for graphs that don’t have many edges, which is called a sparse graph.

The time it takes to run Kruskal's depends mainly on two things:

1. Sorting the edges: This takes $O(E \log E)$ time.
2. Union-Find operations: This part takes $O(E \alpha(V))$ time, with $\alpha$ being a special function related to the graph's size.

Overall, Kruskal's runs in about $O(E \log E)$ time. This makes it fast for graphs where the number of edges E is much lower than the square of the number of vertices V (that is, $E < V^2$).

Prim's Algorithm, on the other hand, works best for graphs that have a lot of edges, known as dense graphs.

Its efficiency can be better if we use different setups. The time it takes to run Prim's can change based on how we implement it:

1. If we use an adjacency matrix: The time is $O(V^2)$.
2. If we use a priority queue with a binary heap: The time is $O(E \log V)$.

Because of these time differences, Prim's Algorithm is usually faster for dense graphs, especially when there are lots of edges (when E is close to V²).

Summary:

• Kruskal's Algorithm: Best for sparse graphs; It runs in about $O(E \log E)$ time.
• Prim's Algorithm: Best for dense graphs; It runs in a range from $O(V^2)$ to $O(E \log V)$ time.

In the end, whether to use Kruskal's or Prim's Algorithm depends on how the graph is structured and what you need in computer science applications.