The first requires us to
repeatedly find the smallest edge between nodes in the MST and nodes
not in the MST. That should be implementable as an O(m) operation.
We do that O(n) times (there are n-1 edges in the MST), so the overally
running time is O(n*m).

The second requires us to repeatedly look at the smallest remaining
edge. If we put the edges in a heap, then we can do each smallest
operation in O(log_2(m)) time, giving an overally running time of
O(m*log_2(m)).

Pick an edge in the MST computed in the second algorithm and add it to SST. + That edge forms a cycle. If it was in the MST, then it must have
been picked before another edge in the cycle.

This means that there is another edge in that cycle with weight
greater than that of the edge we picked.

We can improve SST by replacing that edge with the one from MST.

So SST wasn't a minimum spanning tree.

This proof assumes that no two edges have the same weight. With
some effort, we can show that it also holds if multiple edges can
have the same weight (basically, we have to find a cycle in which
the edge we add has smaller weight).

We can also ensure that no two edges have the same weight by
modifying the weight of each two identical edges slightly (by a
weight that is smaller than 1/(# of edges) or some such).

Can we do the proof for the other version? Yes, but it's more
difficult. Basically, we consider the point at which we add a
edge to the MST that's not in the SST. There must be some other
path in SST from "MST so far" to the node that edge connects.
If we add the edge to the SST, we form a cycle. As before, we
can then make the SST smaller by using that edge.