What you are doing here is in fact defining a hash function: given an encryption function Encrypt(K, M) where K is the key and M is the plaintext to encrypt, you define Hash(P) = Encrypt(P, P). So you are inventing a new cryptographic function.
First, for password hashing, you don't need any old hash function, because it needs to be resistant to brute force cracking attempt, where the attacker guesses what the password might be, calculates Hash(guess) and compares the result with the stored hash. Whatever hash algorithm you do, you need to beef it up to include salt (so that attackers have to crack each hash individually rather than going for all accounts at once and making the weaker passwords fall) and make the hash function slow (because that hurts the attacker, who needs to make a lot of wrong guesses, more than the defender, who'll be mostly verifying correct attempts). See How to securely hash passwords? for a more detailed explanation.
You can build a slow, salted hash function from an ordinary hash function, with a construction like SSH(P, S) = Hash(Hash(…Hash(P + S)…)) (where P + S is concatenation). This is not necessarily the best way to do it — for example, a good password hashing function for typical uses should require a lot of memory, because servers have a lot more memory than specialized password cracking hardware. But it's a good start.
The problem remains whether Hash(P) = Encrypt(P, P) is a good hash function. This is not automatic; beware that some analyses of the security of cryptographic algorithms rely on the key and the plaintext being independent.
A major difficulty is that the key size in most encryption algorithm is heavily constrained, often constant. For example, the standard encryption algorithm AES only accepts three key sizes (8, 12 or 16 bytes). If the password (plus salt) is too short, you can pad it with an invalid character, but what can you do if it's too long? The usual way to use a key based on material that's longer than the key size is… to apply a hash function (accepting an arbitrary input length) to the material.
If you want to derive a hash function from an encryption algorithm, there's actually a simpler way: instead of Hash(P) = Encrypt(P, P), define Hash(P) = Encrypt(P, 0), i.e. encrypt an all-zeros plaintext block (or some other well-known plaintext block). That's what the original Unix password hashing function did. The advantage of this approach over Encrypt(P, P) is that you can benefit from existing analyses of the algorithm: encryption algorithms are designed to be resistant to known-plaintext attacks. The limitation with the password and salt size remains.