Program perl 数据结构

Table of Contents

• 1 数组的数组
  • 1.1 创建和访问二维数组
  • 1.2 自行生长
  • 1.3 访问和打印
  • 1.4 片段
• 2 数组的散列
  • 2.1 数组的散列的组成
  • 2.2 生成数组的散列
  • 2.3 访问和打印数组
• 3 散列的数组
  • 3.1 散列的数组的组成。
  • 3.2 生成散列的数组
  • 3.3 访问和打印散列的数组
• 4 散列的散列
  • 4.1 散列的散列的组成
  • 4.2 生成散列的散列
  • 4.3 访问和打印散列的散列
• 5 函数的散列
• 6 以上内容摘自大骆驼，谢谢

1 数组的数组

 

1.1 创建和访问二维数组

创建是最简单的，举例：

 1:  @AoA = (["fruit","ball"],
 2:          ["home","bart","marge"],
 3:          ["george","jane","elory"]);
 4:  print $AoA[2]->[1];
 5:  #每一对相邻的大括号或中括号之间有一个隐含的->,所以也可以这样写
 6:  print $AoA[2][1];
 7:  
 8:  #整个列表被封装在小括号中，而不是中括号中，因为是给列表赋值，
 9:  #而不是给引用赋值，如果要创建一个指向数组的引用，那么你要这样
10:  $ref_to_AoA =[ ["fred","barney","pebbles","bamm"],
11:                 ["homer","bart","marge","maggie",]
12:      ];
13:  print $ref_to_AoA->[2][3];
14:  #注意这里有在中括号前面的箭头符号。因为这是引用，所以要在前面加上->
15:  
16:  #还有一点就是可以利用负数索引从数组后面向前计数，
17:  $AoA[0][-2];
18:  #表示第一行的倒数第二个元素

1.2 自行生长

我们读入一个数据结构，是一个纯文本文件，每一行是一个结构的一行，并且没行 包含由空白分割的元素。

 1:  while(<>)
 2:  {
 3:      chomp;
 4:      @tmp = split;
 5:      push @AoA,[@tmp];
 6:  }
 7:  #或者直接不用命名那个数组
 8:  while(<>)
 9:  {
10:      push @AoA, [split];
11:  }
12:  #如果想要引用指向一个数组的数组，可以这样
13:  while(<>)
14:  {
15:      push @ref_to_AoA,[split];
16:  }
17:  #如果要向数组中增加列，还是使用简单的赋值
18:  #如果向一个存在的行中附加一个新列
19:  push @{@AOA[0]},"wilma","betty";
20:  #注意push的参数必须以@开头

1.3 访问和打印

 1:  #单元素打印
 2:  print $AoA[3][2];
 3:  #遍历整个数组
 4:  for $now (@AoA)
 5:  {
 6:      print "@$row\n";
 7:  }
 8:  #如果你想追踪脚标
 9:  for $i (0..$#AoA)
10:  {
11:      print "row $i is:@{$AoA[$i]}\n";
12:  }
13:  #或者
14:  for $i (0..$#AoA)
15:  {
16:      for $j (0..$#{$AoA[$i]})
17:      {
18:          print "element $i $j is $AoA[$i][$j]\n";
19:      }
20:  }
21:  #为了简化上面的程序，我们可以使用临时变量，让事情变的简单。
22:  for $i (0..$#AoA)
23:  {
24:      $row = $AoA[$i];
25:      for $j (0..$@{$row})
26:      {
27:          print "element $i $j is $row->[$j]\n";
28:      }
29:  }

1.4 片段

如果要访问一个多维数组的某一片段的元素，你可以用循环把变量一个个的取出来。

 1:  @part = ();
 2:  for ($y = 7 ;$y <13 ;$y++)
 3:  {
 4:      push @part,$AoA[4][$y];
 5:  }
 6:  #这个循环可以用一个数组片段来替代
 7:  @part = @{$AoA[4]} [7..12];
 8:  #如果要一个二维片段，同样也可以通过循环来获得
 9:  #也可以用上面刚学到的方法
10:  for ($x=4;$x<=9;$x++)
11:  {
12:      push @new_AoA,[@{$AoA[$x]} [7..12]];
13:  }
14:  #如果你经常这么做，可以写一个子程序，或者到CPAN上下载一个
15:  #PDL（perl data language)模块

2 数组的散列

关于这个名称，我们可以这样理解，数组的散列是由“数组”组成的散列， 我们可以首先可以根据散列的key快速找到数组，然后再访问数组。

2.1 数组的散列的组成

1:  %HoA = ( flintstones =>["fred","barney"],
2:           jetsons     =>["george","jane","elroy"],
3:      );
4:  #向散列增加另一个数组
5:  $HoA{teletubbies} = ["tinky","dispay","laa",];

2.2 生成数组的散列

从下面格式的文件中读取： flintsotnes: fred barney wilma dino
jetsons: george jane elroy
simpsons: homer marge bart
下面是填充数组的散列的技巧

 1:  while(<>)
 2:  {
 3:      next unless s/^(.*?):\s*//;
 4:      $HoA{$i}=[split];
 5:  }
 6:  #或者
 7:  while($line = <>)
 8:  {
 9:      ($who,$rest)=split/:\s*/,$line,2;
10:      @fields=split ' ',$rest;
11:      $HoA{$who}=[@fields];
12:  }
13:  #可以通过一下方法向已存在的数组追加新的成员
14:  push @{$HoA{flintstones}},"wilma","pebbles";

2.3 访问和打印数组

打印所有的元素

 1:  for $family (keys %HoA)
 2:  {
 3:      print "$family: @{$HoA{$family}}\n";
 4:  }
 5:  #你可以为数组增加索引
 6:  for $family (keys %HoA)
 7:  {
 8:      print "$family: ";
 9:      for $i (0..$#{$HoA{$family}})
10:      {
11:          print " $i = $HoA{$family}[$i]";
12:      }
13:      print "\n";
14:  }
15:  #或者通过以数组拥有的元素个数对他们排序
16:  for $family (sort {@{$HoA{$b}} <=> @{$HoA{$a}}} keys %HoA)
17:  {
18:      print "$family: @{$HoA{$family}}\n";
19:  }
20:  #也可以以元素的个数对数组排序，然后以元素的ASCII码顺序进行排序
21:  for $family (sort {@{$HoA{$b}}<=>@{$HoA{$a}}} keys %HoA)
22:  {
23:      print "$family: ",join(",",sort @{$HoA{$family}}),"\n";
24:  }

3 散列的数组

这个名称和上一个名称容易混淆，散列的数组，就是由“散列“组成的”数组“， 我们的本意是对一堆数据，想要按照顺序访问他们。并且每一个记录后面又 包含key/value对

3.1 散列的数组的组成。

 1:  @AoH = ({husband => "barney",
 2:           wife    => "betty",
 3:           son     => "bamm",
 4:          },
 5:          {husband => "george",
 6:           wife    => "jane",
 7:           son     => "elroy",
 8:          },
 9:          {husband => "homer",
10:           wife    => "marge",
11:           son     => "bart",
12:          },
13:  );
14:  
15:  
16:  #向数组中添加另外一个散列，
17:  push @AoH,{husband => "fred",wife => "wilma",daughter=>"pebbles"};

3.2 生成散列的数组

从文件中读取下面的格式
husband=fred friend=barney

 1:  while(<>)
 2:  {
 3:      $rec = {};
 4:      for $field (split)
 5:      {
 6:          ($key,$value) = split/=/,$field;
 7:          $rec->{$key} = $value;
 8:      }
 9:      push @AoH,$rec;
10:  }
11:  
12:  #或者用下面更简单的方法
13:  while(<>)
14:  {
15:      push @AoH,{split /[\s=]+/};
16:  }
17:  
18:  #可以向下面这样向一个现存的散列添加新成员
19:  $AoH[0]{pet} = "dino";
20:  $AoH[2]{pet} = "santa's";

3.3 访问和打印散列的数组

用下面的方法设置一个特定散列的键/值对

 1:  $AoH[0]{husband} = "fred";
 2:  #把第二个数组的丈夫变成大写
 3:  $AoH[1]{husband} = ~s/(\w)/\u$1/;
 4:  
 5:  #打印所有数据的方法：
 6:  for $href (@AoH)
 7:  {
 8:      print "{ ";
 9:      for $role (keys %$href)
10:      {
11:          print "$role=$href->{$role}";
12:      }
13:      print "}\n";
14:  }
15:  
16:  #带着索引打印
17:  for $i (0..$#AoH)
18:  {
19:      print "$i is {";
20:      for $role (keys %{$AoH[$i]})
21:      {
22:          print "$role=$AoH[$i]{$role} ";
23:      }
24:      print "}\n";
25:  }

4 散列的散列

多维散列是Perl中最灵活的嵌套结构。

4.1 散列的散列的组成

 1:  %HoH=(
 2:  flintstones=>
 3:  {
 4:      husband   => "fred",
 5:      pal       => "barney",
 6:  },
 7:  jetsons  =>
 8:  {
 9:      husband   => "george",
10:      wife      => "jane",
11:      "his boy" => "elroy",
12:  },
13:  simpsons =>
14:  {
15:      husband   => "homer",
16:      wife      => "marge",
17:      kid       => "bart",
18:  },
19:      );
20:  #向%HoH中增加一个匿名散列
21:  $HoH{mash} = {
22:      captain => "pierce",
23:      major   => "burns",
24:      corporal=> "radar",
25:  }

4.2 生成散列的散列

从下面格式的文件中读取数据：

1:  flintstones: husband=fred pal=barney wife=wilma pet=dino

我们可以使用下面两个循环之一来完成任务

 1:  while(<>)
 2:  {
 3:      next unless s/^(.*?):\S*//;
 4:      $who = $1;
 5:      for $field (split)
 6:      {
 7:          ($key,$value)=split/=/,$field;
 8:          $HoH{$who}{$key} = $value;
 9:      }
10:  }
11:  
12:  #或者
13:  while(<>)
14:  {
15:      next unless s/^(.*?):\S*//;
16:      $who = $1;
17:      $rec = {};
18:      $HoH{$who} = $rec;
19:      for $field (split)
20:      {
21:          ($key,$value）= split/=/,$field;
22:          $rec->{$key}= $value;
23:      }
24:  }

4.3 访问和打印散列的散列

 1:  #设置键/值对
 2:  $HOH{flintstones}{wife} = "wilma";
 3:  
 4:  #要把某个键/值对变成大写，可对该元素应用替换
 5:  $HoH{jetsons}{'his boy'} =~s/(\w)/\u$1/;
 6:  
 7:  #打印所有的元素，利用先后遍历内外层散列键的方法
 8:  for $family (keys %HoH)
 9:  {
10:      print "$family: ";
11:      for $role (keys %{$HoH{$family}})
12:      {
13:          print "$role = $person ";
14:      }
15:      print "\n";
16:  }
17:  
18:  #在非常大的散列中，可以用each同时把键和值都检索出来
19:  while (($family,$roles) = each %HoH)
20:  {
21:      print "$family: ";
22:      while (($role,$person) = each %$roles)
23:      {
24:          print "$role = $person";
25:      }
26:      print "\n";
27:  }
28:  
29:  #排序输出
30:  for $family (sort keys %HoH)
31:  {
32:      print "$family: ";
33:      for $role (sort keys %{$HoH{$family}})
34:      {
35:          print "$role=$HoH{$family}{$role} ";
36:      }
37:      print "\n";
38:  }

5 函数的散列

 

6 以上内容摘自大骆驼，谢谢

 

Author: GRC <grc@grc>

Date: 2013-05-31 19:22:49 CST

HTML generated by org-mode 6.33x in emacs 23