I think the simplest explanation is by analogy to the one-dimensional case:
1) Let f be a polynomial of odd degree over the reals. Take a large "circle", i.e. a pair of points (x, -x) where x is some large number. Since f behaves like its highest degree term, the circle's image under f lies on different sides of 0. If you gradually diminish the circle to nothing, its image must cross 0 at some point. So the polynomial has a root.
2) Let f be a polynomial of positive degree over the complex numbers. Take a large circle, i.e. a set of points z such that |z| is some large number. Since f behaves like its highest degree term, the circle's image under f winds n times around 0. If you gradually diminish the circle to nothing, its image must cross 0 at some point. So the polynomial has a root. (It crosses 0 each time the winding number decreases by 1, which is why you have n roots.)
If you want some visuals, here is something I made a few months ago: https://math.berkeley.edu/~kmill/math54fa16/roots/roots.html (it accepts polynomials in any reasonable format, factored or not, and gives both the domain coloring and the circle image). I thought I had implemented a visualization for Gauss's original proof, but I only did that for the reverse problem of giving the roots (and poles) and seeing the zero curves for the real and imaginary parts: http://www.kylem.net/stuff/homsim/homsim2.html (hit tab a few times).
For dealing with non-polynomials, I made https://math.berkeley.edu/~kmill/tools/zgraph/zgraph.html shortly after. It handles most complex functions, like polynomials, quotients, exponentiation, the exponential function, logarithms, and trigonometric functions (though possibly not inverse trigonometric functions). This gives the domain coloring along with the Riemann sphere. One day I'll add the ability to define functions so that one may, for instance, explore Moebius transformations.
This second program works by compiling the input complex function into a shader program (which is output to the Javascript console, and it might be more interesting than the complex analysis itself to some people here).
I love it, especially that the natural logarithm is acually named `ln'.
I wrote myself a mapper of the complex plane for fractal generation that compiles expressions to in-memory closures to compute iterations and coloring. If I set the iteration count to 1, it produces similar images. But it's a shell command only, eating an ASCII file and producing PNG. No web iterface (yet).
This interactive visualization lets you see that the number of times the polynomial function "winds" around the circumference of the circle is equal to the number of zeroes inside the same circle.
(Caveat: the interaction to move the zeroes around requires a mouse.)
1) Let f be a polynomial of odd degree over the reals. Take a large "circle", i.e. a pair of points (x, -x) where x is some large number. Since f behaves like its highest degree term, the circle's image under f lies on different sides of 0. If you gradually diminish the circle to nothing, its image must cross 0 at some point. So the polynomial has a root.
2) Let f be a polynomial of positive degree over the complex numbers. Take a large circle, i.e. a set of points z such that |z| is some large number. Since f behaves like its highest degree term, the circle's image under f winds n times around 0. If you gradually diminish the circle to nothing, its image must cross 0 at some point. So the polynomial has a root. (It crosses 0 each time the winding number decreases by 1, which is why you have n roots.)