perl的sort函數

一） sort函數

sort LIST
sort BLOCK LIST
sort SUBNAME LIST

sort的用法有如上3種形式。它對LIST進行排序，並返回排序後的列表。假如忽略了SUBNAME或BLOCK，sort按標準字串比較順序來進行（例如ASCII順序）。若是指定了SUBNAME，它其實是個子函數的名字，該子函數對比2個列表元素，並返回一個小於，等於，或大於0的整數，這依賴於元素以何種順序來sort（升序，恆等，或降序）。也可提供一個BLOCK做爲匿名子函數來代替SUBNAME，效果是同樣的。

被比較的2個元素，會被臨時賦值給變量$a和$b。它們以引用傳遞，因此不要修改$a或$b。假如使用子函數，它不能是遞歸函數。



（二） 用法示例

1. 以數字順序sort

@array = (8, 2, 32, 1, 4, 16);
print join(' ', sort { $a <=>; $b } @array), "\n";

打印結果是：
1 2 4 8 16 32

與之同樣的是：

sub numerically { $a <=>; $b };
print join(' ', sort numerically @array), "\n";

這個很容易理解哦，它只是按天然數的順序進行sort，偶就不細講了。

2.1 以ASCII順序（非字典順序）進行sort

@languages = qw(fortran lisp c c++ Perl python java);
print join(' ', sort @languages), "\n";

打印結果：
Perl c c++ fortran java lisp python

這等同於：
print join(' ', sort { $a cmp $b } @languages), "\n";

按ASCII的順序進行排序，也沒什麼說的哦。

注意，若是對數字按ASCII順序進行sort的話，結果可能與你想的不一樣：

print join(' ', sort 1 .. 11), "\n";
1 10 11 2 3 4 5 6 7 8 9

2.2 以字典順序sort

use locale; 
@array = qw(ASCII ascap at_large atlarge A ARP arp);
@sorted = sort { ($da = lc $a) =~ s/[\W_]+//g;
          ($db = lc $b) =~ s/[\W_]+//g;
          $da cmp $db;
          } @array ;
print "@sorted\n";

打印結果是：
A ARP arp ascap ASCII atlarge at_large

use locale是可選的--它讓code兼容性更好，假如原始數據包含國際字符的話。use locale影響了cmp,lt,le,ge,gt和其餘一些函數的操做屬性--更多細節見perllocale的man page。

注意atlarge和at_large的順序在輸出時顛倒了，儘管它們的sort順序是同樣的（sort中間的子函數刪掉了at_large中間的下劃線）。這點會發生，是由於該示例運行在perl 5.005_02上。在perl版本5.6前，sort函數不會保護有同樣values的keys的前後順序。perl版本5.6和更高的版本，會保護這個順序。

注意哦，不論是map,grep仍是sort，都要保護這個臨時變量$_（sort裏是$a和$b）的值，不要去修改它。在該code裏，在對$a或$b進行替換操做s/[\W_]+//g前，先將它們從新賦值給$da和$db，這樣替換操做就不會修改原始元素哦。

3. 以降序sort

降序sort比較簡單，把cmp或<=>;先後的操做數調換下位置就能夠了。

sort { $b <=>; $a } @array ;

或者改變中間的塊或子函數的返回值的標記：

sort { -($a <=>; $b) } @array ;

或使用reverse函數（這有點低效，但也許易讀點）：

reverse sort { $a <=>; $b } @array ;

4. 使用多個keys進行sort

要以多個keys來sort，將全部以or鏈接起來的比較操做，放在一個子函數裏便可。將主要的比較操做放在前面，次要的放在後面。

# An array of references to anonymous hashes
@employees = ( 
  { FIRST =>; 'Bill',   LAST =>; 'Gates',   
    SALARY =>; 600000, AGE =>; 45 },
  { FIRST =>; 'George', LAST =>; 'Tester'   
    SALARY =>; 55000, AGE =>; 29 },
  { FIRST =>; 'Steve', LAST =>; 'Ballmer',   
    SALARY =>; 600000, AGE =>; 41 } 
  { FIRST =>; 'Sally', LAST =>; 'Developer', 
    SALARY =>; 55000, AGE =>; 29 },
  { FIRST =>; 'Joe',   LAST =>; 'Tester',   
    SALARY =>; 55000, AGE =>; 29 },
);
sub seniority {
  $b->;{SALARY}   <=>; $a->;{SALARY}
  or $b->;{AGE}   <=>; $a->;{AGE}
  or $a->;{LAST}   cmp $b->;{LAST}
  or $a->;{FIRST}   cmp $b->;{FIRST}
}
@ranked = sort seniority @employees;
foreach $emp (@ranked) {
  print "$emp->;{SALARY}\t$emp->;{AGE}\t$emp->;{FIRST} 
    $emp->;{LAST}\n";
}

打印結果是：

600000 45     Bill Gates
600000 41     Steve Ballmer
55000   29     Sally Developer
55000   29     George Tester
55000   29     Joe Tester

上述code看起來很複雜，實際上很容易理解哦。@employees數組的元素是匿名hash。匿名hash其實是個引用，可以使用->;操做符來訪問其值，例如$employees[0]->;{SALARY}可訪問到第一個匿名hash裏SALARY對應的值。因此上述各項比較就很清楚了，先比較SALARY的值，再比較AGE的值，再比較LAST的值，最後比較FIRST的值。注意前2項比較是降序的，後2項是升序的，不要搞混了哦。

5. sort出新數組

@x = qw(matt elroy jane sally);
@rank[sort { $x[$a] cmp $x[$b] } 0 .. $#x] = 0 .. $#x;
print "@rank\n";

打印結果是：

2 0 1 3

這裏是否有點糊塗呀？仔細看就清楚了。0 .. $#x是個列表，它的值是@x數組的下標，這裏就是0 1 2 3。$x[$a] cmp $x[$b] 就是將@x裏的各個元素，按ASCII順序進行比較。因此sort的結果返回對@x的下標進行排序的列表，排序的標準就是該下標對應的@x元素的ASCII順序。

還不明白sort返回什麼？讓咱們先打印出@x裏元素的ASCII順序：

@x = qw(matt elroy jane sally);
print join ' ',sort { $a cmp $b } @x ;

打印結果是：elroy jane matt sally

它們在@x裏對應的下標是1 2 0 3，因此上述sort返回的結果就是1 2 0 3這個列表了。@rank[1 2 0 3] = 0 .. $#x 只是個簡單的數組賦值操做，因此@rank的結果就是(2 0 1 3)了。

6. 按keys對hash進行sort

%hash = (Donald =>; Knuth, Alan =>; Turing, John =>; Neumann);
@sorted = map { { ($_ =>; $hash{$_}) } } sort keys %hash;
foreach $hashref (@sorted) {
  ($key, $value) = each %$hashref;
  print "$key =>; $value\n";
}

打印結果是：

Alan =>; Turing
Donald =>; Knuth
John =>; Neumann

上述code不難明白哦。sort keys %hash按%hash的keys的ASCII順序返回一個列表，而後用map進行計算，注意map這裏用了雙重{{}}，裏面的{}是個匿名hash哦，也就是說map的結果是個匿名hash列表，明白了呀？

因此@sorted數組裏的元素就是各個匿名hash，經過%$hashref進行反引用，就能夠訪問到它們的key/value值了。

7. 按values對hash進行sort

%hash = ( Elliot =>; Babbage, 
      Charles =>; Babbage,
      Grace =>; Hopper,
      Herman =>; Hollerith
    );
@sorted = map { { ($_ =>; $hash{$_}) } } 
        sort { $hash{$a} cmp $hash{$b}
              or $a cmp $b
            } keys %hash;
foreach $hashref (@sorted) {
  ($key, $value) = each %$hashref;
  print "$key =>; $value\n";
}

打印結果是：

Charles =>; Babbage
Elliot =>; Babbage
Herman =>; Hollerith
Grace =>; Hopper

本文做者如是說，偶以爲很重要：

與hash keys不一樣，咱們不能保證hash values的惟一性。假如你僅根據values來sort hash，那麼當你增或刪其餘values時，有着相同value的2個元素的sort順序可能會改變。爲了求得穩定的結果，應該對value進行主sort，對key進行從sort。

這裏{ $hash{$a} cmp $hash{$b} or $a cmp $b } 就先按value再按key進行了2次sort哦，sort返回的結果是排序後的keys列表，而後這個列表再交給map進行計算，返回一個匿名hash列表。訪問方法與前面的相同，偶就不詳敘了。

8. 對文件裏的單詞進行sort，並去除重複的

perl -0777ane '$, = "\n"; \
  @uniq{@F} = (); print sort keys %uniq' file

你們試試這種用法，偶也不是很明白的說，:(

@uniq{@F} = ()使用了hash slice來建立一個hash，它的keys是文件裏的惟一單詞；該用法在語意上等同於$uniq{ $F[0], $F[1], ... $F[$#F] } = ()。

各選項說明以下：

-0777   -   讀入整個文件，而不是單行
-a     -   自動分割模式，將行分割到@F數組
-e     -   從命令行讀取和運行腳本
-n     -   逐行遍歷文件：while (<>;) { ... }
$,     -   print函數的輸出域分割符
file   -   文件名

9. 高效sorting: Orcish算法和Schwartzian轉換

對每一個key，sort的子函數一般被調用屢次。假如很是在乎sort的運行時間，可以使用Orcish算法或Schwartzian轉換，以便每一個key僅被計算1次。

考慮以下示例，它根據文件修改日期來sort文件列表。

# 強迫算法--對每一個文件要屢次訪問磁盤
@sorted = sort { -M $a <=>; -M $b } @filenames;

# Orcish算法--在hash裏建立keys
@sorted = sort { ($modtimes{$a} ||= -M $a) <=>;
          ($modtimes{$b} ||= -M $b)
          } @filenames;

很巧妙的算法，是否是？由於文件的修改日期在腳本運行期間是基本不變的，因此-M運算一次後，把它存起來就能夠了呀。偶就常常這麼用的，:p

以下是Schwartzian轉換的用法：

@sorted = map( { $_->;[0] }   
          sort( { $a->;[1] <=>; $b->;[1] }
              map({ [$_, -M] } @filenames)
            )
        );

這個code結合用了map,sort分了好幾層，記住偶之前提過的方法，從後往前看。map({ [$_, -M] } @filenames)返回一個列表，列表元素是匿名數組，匿名數組的第一個值是文件名，第二個值是文件的修改日期。

sort( { $a->;[1] <=>; $b->;[1] }...再對上述產生的匿名數組列表進行sort，它根據文件的修改日期進行sort。sort返回的結果是通過排序後的匿名數組。

最外圍的map( { $_->;[0] }...就簡單了，它從上述sort產生的匿名數組裏提取出文件名。這個文件名就是根據修改日期進行sort過的呀，而且每一個文件只運行了一次-M。

這就是著名的Schwartzian轉換，這種用法在國外perl用戶裏很流行。記住仙子告訴你的Schwartzian概念哦，下次就不會被老外laugh at了，:p

本文做者說：

Orcish算法一般更難於編碼，而且不如Schwartzian轉換文雅。我推薦你使用Schwartzian轉換做爲可選擇的方法。

也請記住基本的優化code的規則：(1)不寫code；(2)在使code快速以前，先保證其正確；(3)在使code快速以前，先讓它清楚。

10. 根據最後一列來對行進行sort（Schwartzian轉換）

假如$str的值以下（每行以\n終結）：

eir   11   9   2   6   3   1   1   81%   63%   13
oos   10   6   4   3   3   0   4   60%   70%   25
hrh   10   6   4   5   1   2   2   60%   70%   15
spp   10   6   4   3   3   1   3   60%   60%   14

按最後1個域的大小進行sort:

$str = join "\n", 
        map { $_->;[0] }
          sort { $a->;[1] <=>; $b->;[1] }
              map { [ $_, (split)[-1] ] }
                split /\n/, $str; 

打印結果是：

eir   11   9   2   6   3   1   1   81%   63%   13
spp   10   6   4   3   3   1   3   60%   60%   14
hrh   10   6   4   5   1   2   2   60%   70%   15
oos   10   6   4   3   3   0   4   60%   70%   25

讓咱們從後往前，一步一步看上述code：

split /\n/, $str; 這裏返回一個列表，列表元素就是各個行了。

map { [ $_, (split)[-1] ] } 這裏的map求得一個匿名數組列表，匿名數組的值分別是整行，和該行的最後一列。使用Schwartzian轉換時，這步是關鍵哦，記着用map來構造你本身的匿名數組列表，匿名數組的第1個元素是最終須要的值，第2個元素是用於比較的值。

sort { $a->;[1] <=>; $b->;[1] } 對上1步中產生的匿名數組，按第2個元素進行sort，它返回sort後的匿名數組列表。

map { $_->;[0] } 對上1步中sort後的匿名數組，提取出第1個元素，也就是整行哦。

$str = join "\n", 把上步中的各行用"\n"鏈接起來，並賦值給$str。

也許你會說：「怎麼這麼麻煩呀？偶不想用這種方式。」那麼，可用CPAN上的現成模塊來代替：

use Sort::Fields;
@sorted = fieldsort [ 6, '2n', '-3n' ] @lines ; CPAN的模塊文檔很詳細的，本身看看呀。 11. 重訪高效sorting: Guttman-Rosler轉換 考慮以下示例： @dates = qw(2001/1/1 2001/07/04 1999/12/25); 你想按日期升序對它們進行排序，哪一種方法最有效呢？ 最直觀的Schwartzian轉換能夠這樣寫： @sorted = map { $_->;[0] }       sort { $a->;[1] <=>; $b->;[1]           or $a->;[2] <=>; $b->;[2]           or $a->;[3] <=>; $b->;[3]           }       map { [ $_, split m</>; $_, 3 ] } @dates; 然而，更高效的Guttman-Rosler轉換(GRT)這樣寫： @sorted = map { substr $_, 10 }       sort       map { m|(\d\d\d\d)/(\d+)/(\d+)|;           sprintf "%d-%02d-%02d%s", $1, $2, $3, $_         } @dates; 本文做者說： GRT方法難於編碼，而且比Schwartzian轉換更難閱讀，因此我推薦僅在極端環境下使用GRT。使用大的數據源，perl 5.005_03和linux 2.2.14進行測試，GRT比Schwartzian轉換快1.7倍。用perl 5.005_02和windows NT 4.0 SP6進行測試，GRT比Schwartzian快2.5倍。 另外，perl 5.6及更高版本的sort使用Mergesort算法，而5.6以前的sort使用Quicksort算法，前者顯然快於後者，因此，要想求速度，也要升級你的perl版本哦。