Historically, most software applications have respected a very simple schema of versioning, whenever they were operating systems or simple applications.
The basic schema is a sequence-based identifier:
Major versions indicate big releases, usually fully new versions an many times partial or full rewrites of the code behind.
Minor versions indicate important releases, smaller new functionalities, bugfix collections and other changes that, while not worth a full version, are relatively important (and recommended to update to).
Build is not always used, but represents minor bugfixes or minor improvements.
Revision is often hidden, and represents the compilation or revision number. Can be manually set, or automatically tagged within a continuous integration system (for example after a stable build).
And also, to tag those releases that were not stable (or even in early development stages), we would use the following terms:
Alpha: Software in this state is under heavy development and subject to changes. Anything can change, from visual aspects to code or application behaviour. Intended for early testing only.
Beta: When reaches beta state, software becomes more stable and most major functionality is usually present (albeit can be unstable or not fully implemented). There can still be somewhat big changes, but can be used for broader, general purpose testing and gathering feedback.
Release Candidate: Pending only bugfixes, and not adding any new functionality or noticeable UI change, a software in RC is just a bit unstable and maybe not as fast as the final version, but overall represents the final product. Usually is only weeks away from final release.
Also there can be multiple RCs with bugfixes (RC1, RC2, etc.).
But that would be pretty easy, no? Sadly, the "standard" has been diluted, ignored and manipulated by many, not being as easy to understand as in the past (but remains very important still).
So let's see some examples of changes to the versioning original schema.
Some software have the versioning hidden and replaced by a name or generic version number, most noticeable examples being Microsoft with Windows (old and new versions lists) and Apple with OSX and the feline names.
Precisely in the case of operating systems, it is interesting to look at the internal numbers because you can learn a lot: For example Windows Server 2008 R2 and Windows 7 share the same kernel version (6.1), while Windows Server 2008 originally was kernel 6.0 (same as Windows Vista).
It looks bad for marketing to sell Windows 7 as an upgrade of Windows Vista (actually Vista looking as some kind of unpolished version of Windows 7), or OSX service packs being named just that, so is much better to hide under pompous names like "OSX crouching cross-eyed tiger" so that we perceive them as "something new and big" and not just paying for updates to things that were not working fine.
Other examples are Adobe with their Photoshop, Flash,... suites. First versioning, then alphanumeric, now a combination ("Adobe Photoshop PS 5")...
And Java ceated some chaos when changed from 1.4 to Java 5 (really 1.5.0), probably just for the PR and because "a bigger number makes you think it is also better stuff".
Microsoft seems to love to mess up our heads with the naming of software. While they still use sometimes the term Beta (for example with Windows 8 Server or IIS 8.0 just released betas), this are some of the terms they have come up with to obfuscate or confuse people:
CTP (Community Technology Preview). Fancy name for the typical "beta". Has exactly the same meaning and same unstable behaviour.
RTM (Release to Manufacturing): aka "going gold". This one is (I think) not original from Microsoft but they use it everywhere. It equals to a final, new, X.0 version.
Service Pack: Collection of bugfixes and sometimes new functionalities. Would be an increase of the minor sequencing version fragment. Can be a +0.1 or higher (some are important, others really minor fixes). Sometimes breaks compatibility (like the dreaded but needed Windows XP Service Packs).
Refresh: Alternative to Service Pack, usually used as a lesser important one. A refresh most times can be ignored without problems, but it does improve or fix stuff.
R2: Used on specific Microsoft software, like Windows Server, Biztalk or SQL Server, means a compilation of service packs, although sometimes can be a big change (like the kernel change between Windows Server 2008 and its R2 version). It can break compatibility.
Developer Preview: New term invented to celebrate Windows 8 beta 1. Represents exactly that, a first public beta.
Customer Preview: Another new term for Windows 8, in this case the beta 2. Both this term and previous one have not been used yet in more software, but might be in the future.
An ankward but not unkown versioning schema is to tag with odd-numbered minor versions those focused for development, and leave even ones for stable releases.
Most notorius cases are Linux kernel (2.3 unstable, 2.4 stable, but since 2.6 they stopped doing it) and Node.js (0.6 stable, 0.7 unstable).
This system is quite annoying and forces you to learn how it works, but then is just a matter of skipping odd versions.
When Google released Chrome, they decided to do many fast iterations. But they also decided to break the traditional versioning, by releasing new major version numbers for changes that most times were small and more appropiate for minor version numbers (+info: release history).
Firefox also followed since version 5.0, and now Microsoft announced also smaller iterations for Internet Explorer, although they seem to be still slow compared with Firefox.
There will probably be more scenarios but this are the major ones I could think about.
I am a big defender of the traditional way (revision being optional and many times not needed) so you will understand the biasing of my opinion on the invented names or rule breakings, but we have to live with them. Just try to not spread the disease more ;)
Bonus: At the wikipedia you can find funny superstition stories.