G'day Eshan_k,

"I am beginner in perl."

Yes, indeed. I strongly recommend that you read "perlintro -- Perl introduction for beginners". It's a fairly short read (under a dozen screenfuls on my monitor) and will take you through the basics. Perhaps more importantly, every section is peppered with links to more detailed discussions and advanced topics: it's a great reference source when your coding requirements become more complex.

The test data you posted has serious problems: you're assigning hashrefs to undeclared hashes which will end up having a single key, which looks something like "HASH(0x7fc1c3005498)", and a single undef value. The strict and warnings pragmata (both introduced at the start of perlintro) would have alerted you to this.

I see you've added additional information (the code you tried and the problem you had) in "Re^2: Compare two Hashes of Hashes". Consider this a reply to them both.

In the code below,

• I've abstracted the key comparison into a single function, comp_keys(): you simply pass it two hashrefs and it compares the keys. This eliminates your first-level/second-level problems as it has no knowledge of the source level; in fact, you could use it to compare the keys at any level.
• The value comparison function, comp_vals(), is much simpler; although, it does expect that comp_keys() has been run first. It's not run for the first-level keys as their values should all be hashrefs (but you might want some validation in production-grade code). It doesn't need to check the number of values: there's one for each key and that's already been checked.
• The ary2str() function perhaps needs some explanation. This is aiming to join the array of strings using a character not found elsewhere. Consider the problem of joining the elements of two quite different arrays, ('a', 'b-c') and ('a-b', 'c'), with a dash ('-'): both result in the same string, 'a-b-c'. I find $; to be quite handy in this situation: it used to be used to create complex data structures in Perl4 (before we had references, in Perl5) and it's unlikely to occur in any hash values. It's just used a joiner here: if it's unsuitable for your needs, pick something else. You can read more about it in perlvar.

Here's my test code:

#!/usr/bin/env perl -l

use strict;
use warnings;

{
    my @tests = (
        { x => { a => 1, b => 2 }, y => { c => 3} },
        { x => { a => 1, b => 2 }, z => { c => 3} },
        { x => { a => 1, b => 2 }, y => { c => 3}, z => {} },
        { x => { a => 1, b => 2 }, y => { c => 3, d => 4 } },
        { x => { a => 1, b => 2 }, y => { d => 3} },
        { x => { a => 1, d => 2 }, y => { c => 3} },
        { x => { a => 1, b => 2 }, y => { c => 4} },
    );

    for (0 .. $#tests) {
        print "Comparing \$tests[0] with \$tests[$_]";
        comp($tests[0], $tests[$_]);
        print '-' x 40;
    }
}

sub comp {
    my ($h1, $h2) = @_;

    return unless comp_keys($h1, $h2);

    for (sort keys %$h1) {
        print "Comparing keys in '$_' hashref.";
        return unless comp_keys($h1->{$_}, $h2->{$_});

        print "Comparing values in '$_' hashref.";
        return unless comp_vals($h1->{$_}, $h2->{$_});
    }
}

sub comp_keys {
    my ($h1, $h2) = @_;

    my @keys = ([sort keys %$h1], [sort keys %$h2]);

    if (@{$keys[0]} == @{$keys[1]}) {
        print "Same number of keys.";

        if (ary2str($keys[0]) eq ary2str($keys[1])) {
            print "Same keys.";
        }
        else {
            print "Different keys.";
            return 0;
        }
    }
    else {
        print "Different number of keys.";
        return 0;
    }

    return 1;
}

sub comp_vals {
    my ($h1, $h2) = @_;

    my @keys = sort keys %$h1;

    if (ary2str([@$h1{@keys}]) eq ary2str([@$h2{@keys}])) {
        print "Same values";
    }
    else {
        print "Different values";
        return 0;
    }

    return 1;
}

sub ary2str { join $;, @{$_[0]} }
[download]

The output's a tad lengthy (65 lines). It's in the spoiler.

Comparing $tests[0] with $tests[0]
Same number of keys.
Same keys.
Comparing keys in 'x' hashref.
Same number of keys.
Same keys.
Comparing values in 'x' hashref.
Same values
Comparing keys in 'y' hashref.
Same number of keys.
Same keys.
Comparing values in 'y' hashref.
Same values
----------------------------------------
Comparing $tests[0] with $tests[1]
Same number of keys.
Different keys.
----------------------------------------
Comparing $tests[0] with $tests[2]
Different number of keys.
----------------------------------------
Comparing $tests[0] with $tests[3]
Same number of keys.
Same keys.
Comparing keys in 'x' hashref.
Same number of keys.
Same keys.
Comparing values in 'x' hashref.
Same values
Comparing keys in 'y' hashref.
Different number of keys.
----------------------------------------
Comparing $tests[0] with $tests[4]
Same number of keys.
Same keys.
Comparing keys in 'x' hashref.
Same number of keys.
Same keys.
Comparing values in 'x' hashref.
Same values
Comparing keys in 'y' hashref.
Same number of keys.
Different keys.
----------------------------------------
Comparing $tests[0] with $tests[5]
Same number of keys.
Same keys.
Comparing keys in 'x' hashref.
Same number of keys.
Different keys.
----------------------------------------
Comparing $tests[0] with $tests[6]
Same number of keys.
Same keys.
Comparing keys in 'x' hashref.
Same number of keys.
Same keys.
Comparing values in 'x' hashref.
Same values
Comparing keys in 'y' hashref.
Same number of keys.
Same keys.
Comparing values in 'y' hashref.
Different values
----------------------------------------
[download]