Why? In Perl you can use an array to efficiently insert and remove elements from anywhere in a list and trivially reverse it if you wish. In fact the easiest way to handle your problem is to convert between a Perl list and a linked list:

use strict;
use warnings;
use Data::Dumper;

my $forwardList = buildList(1 .. 4);
my $reverseList = buildList(reverse getList($forwardList));

print join (', ', getList($forwardList)), "\n";;
print join (', ', getList($reverseList)), "\n";;


sub buildList {
    my @elements = @_;
    my $head = {data => undef, next => undef};
    my $next = $head;
    
    for my $element (@elements) {
        $next->{data} = $element;
        $next->{next} = {data => undef, next => undef};
        $next = $next->{next};
    }
    
    return $head;
}


sub getList {
    my ($head) = @_;
    my @data;
    
    while ($head) {
        last if !defined $head->{next};
        push @data, $head->{data};
        $head = $head->{next};
    }
    
    return @data;
}
[download]

Prints:

1, 2, 3, 4
4, 3, 2, 1
[download]

Slightly shorter code (slow night):

use strict;
use warnings;
use Data::Dumper;

my $forwardList = buildList(1 .. 4);
my $reverseList = buildList(reverse getList($forwardList));

print join (', ', getList($forwardList)), "\n";;
print join (', ', getList($reverseList)), "\n";;

sub buildList {
  my ($head, $node);
  for (@_){       
     $node = add_node($node,$_);
     $head ||= $node;   
    }
    return $head;
}

sub add_node{
  my ($prev, $data) = @_;
  return $prev->{next} ={data=>$data, next=>undef};
}

sub getList {
    my ($head) = @_;
    my @data = ($head->{data});
    
    while ( $head = $head->{next}) {
        push @data, $head->{data};
    }
    
    return @data;
}
[download]

(The last node points to undef .. there is no empty node)

        "Think of how stupid the average person is, and realize half of them are stupider than that." - George Carlin

$curr = $head;
my $tail;

while ($curr) {
    $tail = { next => $tail,
              data => $curr->{data},
            };
    $curr = $curr->{next};
}

print Dumper $tail;
[download]

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

OK Thanks for the response...
But would you be knowing why the following is running into infinite loop ?
what am I doing wrong here


## Reversing linked list

$curr=$head;


while (defined ($curr->{next})) {
    $curr->{next} = {
                      data =>$curr->{data},
                      next => $curr
                     
                    };
    $curr = $curr->{next};
}

print Dumper $curr;
[download]

Because you always effectively assign next => $curr , hence it's always defined.

Try Data::Dumper to check if your data is what you think it should be.

Cheers Rolf
_{(addicted to the Perl Programming Language and ☆☆☆☆ :)
Je suis Charlie!}

Thanks for the response. And this was very helpful
But one question which I have from your code is that , aren't you creating a new list itself ?
So the original list that was created beginning from the head and all the way down , that still continues to remain unaffected
So after following your approach by creating new tail nodes each time , I agree that we will get a reversed linked list , but the original linked list will continue to be unaffected
How can your approach be modified so that there will exist only one direction of linked list at any time , either forward or backwards ?

You are right. You can either assign the new list to the old one:

$head = $curr;
[download]

The old nodes will be freed, as there's no reference to the head remaining afterwards. Once the head is gone, the next node can be freed, too, and so on.

Or, you can use a bit more complicated procedure to invert the list in place:

$curr = $head;
my $tail;
while ($curr) {
    my $next = $curr->{next};
    $curr->{next} = $tail;
    $tail = $curr;
    $curr = $next;
}
[download]

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]