2. 程式人生 > >用awk寫遞歸

用awk寫遞歸

阿新 • • 發佈：2017-06-27
ron 一個棧 fun 例子 自然 int 可能 tran 為什麽

看到自己很多年前寫的一篇帖子，覺得有些意義，轉錄過來，稍加修改。

awk是一種腳本語言，語法接近C語言，我比較喜歡用，gawk甚至可以支持tcp/ip,用起來非常方便。

awk也支持遞歸，只是awk不支持局部變量，所有的變量都是全局的，於是寫遞歸有些麻煩。本文說白了，也只是借awk說一種編程的思路罷了。

原文如下：

awk支持函數，也支持遞歸。但awk並不支持局部變量，於是看上去遞歸函數很不好實現，因為在某一級調用函數的時候，裏面的變量在該級調用還沒有退出前就可能會被別的調用給修改掉，於是得到的結果會與期望並不一致。
我們考慮C語言，它的局部變量放在硬件支持的棧（一般用棧指針）內。於是我們就去思考，為什麽是棧呢？我們來考慮一個具體的函數調用順序：

f1調用f2;
f2調用f3;
f3返回；
f2調用f4;
f4調用f5;
f5返回；
f4返回；
f2返回；
f1返回；
按照這個循序，我們來思考每個函數開辟的棧空間：
f1的棧空間開辟(f1進棧）
f2的棧空間開辟(f2進棧）
f3的棧空間開辟(f3進棧）
f3的棧空間消亡(f3出棧）
f4的棧空間開辟(f4進棧）
f5的棧空間開辟(f5進棧）
f5的棧空間消亡(f5出棧）
f4的棧空間消亡(f4出棧）
f2的棧空間消亡(f2出棧）
f1的棧空間消亡(f1出棧）
原來跟我們數據結構裏的棧的先進後出是一回事情，所以叫棧。
而當前的我們取的變量的地址都是相對於棧指針來說的，這是相對，而不是像全局變量的那種絕對。
於是我們可以受到啟發，可以擴展這裏的棧指針和地址的概念，awk的遞歸函數就可以出來了。
以下是用遞歸來算一個數組中的最大值（每遞歸一級就把數組分為兩段，每段求最大值），只是舉一個例子，可以擴展到任意應用。

#!/bin/awk -f
func test1(a,start,len)
{
        if(len<=1)
                return a[start];
        x = test1(a,start,int(len/2));
        y = test1(a,start+int(len/2),len-int(len/2));
        return (x>y)?x:y;
}
func test2(a,start,len)
{
        if(len<=1)
                return a[start];
        testlen++;
        testa[testlen] = test2(a,start,int(len/2));
        testlen++;
        testa[testlen] = test2(a,start+int(len/2),len-int(len/2));
        testlen-=2;
        return (testa[testlen+1]>testa[testlen+2])?testa[testlen+1]:testa[testlen+2];
}
func test3(a,start,len)
{
        if(len<=1) {
                return a[start];
        }
        V = V";"test3(a,start,int(len/2));
        V = V";"test3(a,start+int(len/2),len-int(len/2));
        xx = V;
        sub(/.*;/,"",xx);
        sub(/;[^;]+$/,"",V);
        yy = V;
        sub(/.*;/,"",yy);
        sub(/;[^;]+$/,"",V);
        return int(xx)>int(yy)?int(xx):int(yy);
}
NR==1{
        way=$1;
        print $1
}
NR==2{
        max=$1;
        for(i=2;i<=NF;i++)
                if($i > max)
                        max = $i;
        print max;
        for(i=1;i<=NF;i++)
                a[i] = $i;
        if(way == 2)
                print test2(a,1,NF);
        else if(way == 3)
                print test3(a,1,NF);
        else
                print test1(a,1,NF);
        exit(0);
}

這裏面實現了三個遞歸函數，第一個是測試全局變量的汙染，它是得不到正確的答案的
第二個是用數組來模擬變量棧，testlen就是所謂的“棧頂指針”
第三個是用字符串來模擬變量棧，字符串末尾就是“棧頂指針”，每個“局部變量”之間是用分號隔開
用隨機數據測試一下這個應用：

linux-0gt0:/tmp/test # for((i=0;i<10;i++));do  { echo $(($RANDOM % 3 + 1)); let count=$RANDOM%100+50; for((j=0;j<count;j++));do echo -n $(($RANDOM % 10000)) " "; done ; echo ; }|./1.awk ;done | sed -nr ‘N;N;p;/\n(.*)\n\1$/{s/.*/right\n/p;d;};       /^[23]/s/(.).*/\1 SO STRANGE!!!!!!!!!!!!!!!!!!!!!/p; s/.*/wrong\n/p‘
2
9981
9981
right

3
9391
9391
right

1
9919
5257
wrong

2
9860
9860
right

3
9967
9967
right

3
9940
9940
right

3
9828
9828
right

2
9752
9752
right

3
9996
9996
right

2
9930
9930
right

當然，棧的數目自然也可以不只維系一個，test2和test3維系的是一個棧。
現在來實現test4和test5，兩個函數是test2和test3的變體，各自維系兩個棧。

#!/bin/awk -f
#func test1(a,start,len)
#{
#       if(len<=1)
#               return a[start];
#       x = test1(a,start,int(len/2));
#       y = test1(a,start+int(len/2),len-int(len/2));
#       return (x>y)?x:y;
#}
func test2(a,start,len)
{
        if(len<=1)
                return a[start];
        testlen++;
        testa[testlen] = test2(a,start,int(len/2));
        testlen++;
        testa[testlen] = test2(a,start+int(len/2),len-int(len/2));
        testlen-=2;
        return (testa[testlen+1]>testa[testlen+2])?testa[testlen+1]:testa[testlen+2];
}
func test3(a,start,len)
{
        if(len<=1) {
                return a[start];
        }
        V = V";"test3(a,start,int(len/2));
        V = V";"test3(a,start+int(len/2),len-int(len/2));
        xx = V;
        sub(/.*;/,"",xx);
        sub(/;[^;]+$/,"",V);
        yy = V;
        sub(/.*;/,"",yy);
        sub(/;[^;]+$/,"",V);
        return int(xx)>int(yy)?int(xx):int(yy);
}
func test4(a,start,len)
{
        if(len<=1)
                return a[start];
        testlenx++;
        testleny++;
        testax[testlenx] = test4(a,start,int(len/2));
        testay[testleny] = test4(a,start+int(len/2),len-int(len/2));
        testlenx-=1;
        testleny-=1;
        return (testax[testlenx+1]>testay[testleny+1])?testax[testlenx+1]:testay[testleny+1];
}
func test5(a,start,len)
{
        if(len<=1) {
                return a[start];
        }
        V1 = V1";"test5(a,start,int(len/2));
        V2 = V2";"test5(a,start+int(len/2),len-int(len/2));
        xx = V1;
        sub(/.*;/,"",xx);
        sub(/;[^;]+$/,"",V1);
        yy = V2;
        sub(/.*;/,"",yy);
        sub(/;[^;]+$/,"",V2);
        return int(xx)>int(yy)?int(xx):int(yy);
}
NR==1{
        way=$1;
        print $1
}
NR==2{
        max=$1;
        for(i=2;i<=NF;i++)
                if($i > max)
                        max = $i;
        print max;
        for(i=1;i<=NF;i++)
                a[i] = $i;
        if(way == 2)
                print test2(a,1,NF);
        else if(way == 3)
                print test3(a,1,NF);
        else if(way == 4)
                print test4(a,1,NF);
        else if(way == 5)
                print test5(a,1,NF);
        exit(0);
}

測試一下，

linux-0gt0:/tmp/test # for((i=0;i<10;i++));do  { echo $(($RANDOM % 2 + 4)); let count=$RANDOM%100+50; for((j=0;j<count;j++));do echo -n $(($RANDOM % 10000)) " "; done ; echo ; }|./1.awk ;done | sed -nr ‘N;N;p;/\n(.*)\n\1$/{s/.*/right\n/p;d;};       /^[234]/s/(.).*/\1 SO STRANGE!!!!!!!!!!!!!!!!!!!!!/p; s/.*/wrong\n/p‘
5
9904
9904
right

4
9823
9823
right

5
9975
9975
right

4
9966
9966
right

5
9683
9683
right

5
9981
9981
right

4
9983
9983
right

5
9966
9966
right

5
9967
9967
right

5
9870
9870
right

當然，test4和test5各自維系的兩個棧其實差別和一個棧不大，因為兩個棧是同時進棧同時出棧的。
其實，即使兩個棧並非同時進出棧也是可以的，只是對於這裏的例子來說寫不出這麽復雜。
實際上，任意多的棧，任意進出棧，都是可以的。
這樣就可以做到更加靈活的應用。
軟件的擴展性比硬件強，我想，這就是軟件的用處吧。

還是這個取最大值,舉個含有多個棧,每個棧入出並不完全一致的例子,這裏的test6函數

#!/bin/awk -f
func test1(a,start,len)
{
        if(len<=1)
                return a[start];
        x = test1(a,start,int(len/2));
        y = test1(a,start+int(len/2),len-int(len/2));
        return (x>y)?x:y;
}
func test2(a,start,len)
{
        if(len<=1)
                return a[start];
        testlen++;
        testa[testlen] = test2(a,start,int(len/2));
        testlen++;
        testa[testlen] = test2(a,start+int(len/2),len-int(len/2));
        testlen-=2;
        return (testa[testlen+1]>testa[testlen+2])?testa[testlen+1]:testa[testlen+2];
}
func test3(a,start,len)
{
        if(len<=1) {
                return a[start];
        }
        V = V";"test3(a,start,int(len/2));
        V = V";"test3(a,start+int(len/2),len-int(len/2));
        xx = V;
        sub(/.*;/,"",xx);
        sub(/;[^;]+$/,"",V);
        yy = V;
        sub(/.*;/,"",yy);
        sub(/;[^;]+$/,"",V);
        return int(xx)>int(yy)?int(xx):int(yy);
}
func test4(a,start,len)
{
        if(len<=1)
                return a[start];
        testlenx++;
        testleny++;
        testax[testlenx] = test4(a,start,int(len/2));
        testay[testleny] = test4(a,start+int(len/2),len-int(len/2));
        testlenx-=1;
        testleny-=1;
        return (testax[testlenx+1]>testay[testleny+1])?testax[testlenx+1]:testay[testleny+1];
}
func test5(a,start,len)
{
        if(len<=1) {
                return a[start];
        }
        V1 = V1";"test5(a,start,int(len/2));
        V2 = V2";"test5(a,start+int(len/2),len-int(len/2));
        xx = V1;
        sub(/.*;/,"",xx);
        sub(/;[^;]+$/,"",V1);
        yy = V2;
        sub(/.*;/,"",yy);
        sub(/;[^;]+$/,"",V2);
        return int(xx)>int(yy)?int(xx):int(yy);
}
func test6(a,start,len)
{
        if(len <= 1) {
                return a[start];
        } else if(len == 2) {
                return (a[start]>a[start+1])?a[start]:a[start+1];
        } else if(len == 3) {
                var1 = (a[start]>a[start+1])?a[start]:a[start+1];
                return (var1>a[start+2])?var1:a[start+2];
        }
        var2 = int(rand()*10000)%3+2;
        if(var2 == 2) {
                testlenx++;
                testleny++;
                testax[testlenx] = test6(a,start,int(len/2));
                testay[testleny] = test6(a,start+int(len/2),len-int(len/2));
                testlenx-=1;
                testleny-=1;
                return (testax[testlenx+1]>testay[testleny+1])?testax[testlenx+1]:testay[testleny+1];
        } else if(var2 == 3) {
                testlenx++;
                testleny++;
                testlenz++;
                testax[testlenx] = test6(a,start,int(len/3));
                testay[testleny] = test6(a,start+int(len/3),int(len/3));
                testaz[testlenz] = test6(a,start+2*int(len/3),len-2*int(len/3));
                testlenx-=1;
                testleny-=1;
                testlenz-=1;
                var1 = (testax[testlenx+1]>testay[testleny+1])?testax[testlenx+1]:testay[testleny+1];
                return ((var1>testaz[testlenz+1])?var1:testaz[testlenz+1]);
        } else if(var2 == 4) {
                testlenx++;
                testleny++;
                testlenz++;
                testlenA++;
                testax[testlenx] = test6(a,start,int(len/4));
                testay[testleny] = test6(a,start+int(len/4),int(len/4));
                testaz[testlenz] = test6(a,start+2*int(len/4),int(len/4));
                testaA[testlenA] = test6(a,start+3*int(len/4),len-3*int(len/4));
                testlenx-=1;
                testleny-=1;
                testlenz-=1;
                testlenA-=1;
                var1 = (testax[testlenx+1]>testay[testleny+1])?testax[testlenx+1]:testay[testleny+1];
                var4 = (testaz[testlenz+1]>testaA[testlenA+1])?testaz[testlenz+1]:testaA[testlenA+1];
                return ((var1>var4)?var1:var4);
        }
}
BEGIN {
        srand(systime());
}
NR==1{
        way=$1;
        print $1
}
NR==2{
        max=$1;
        for(i=2;i<=NF;i++)
                if($i > max)
                        max = $i;
        print max;
        for(i=1;i<=NF;i++)
                a[i] = $i;
        if(way == 2)
                print test2(a,1,NF);
        else if(way == 3)
                print test3(a,1,NF);
        else if(way == 4)
                print test4(a,1,NF);
        else if(way == 5)
                print test5(a,1,NF);
        else if(way == 6)
                print test6(a,1,NF);
        else
                print test1(a,1,NF);
        exit(0);
}

　　

用awk寫遞歸

相關推薦

用awk寫遞歸

ron 一個棧 fun 例子 自然 int 可能 tran 為什麽 看到自己很多年前寫的一篇帖子，覺得有些意義，轉錄過來，稍加修改。 awk是一種腳本語言，語法接近C語言，我比較喜歡用，gawk甚至可以支持tcp/ip,用起來非常方便。 awk也支持遞歸，只是awk不支

用棧來遞歸 模板 honoi

char post log include sys nbsp stk esp AC 用棧來模擬遞歸的技巧 #define _CRT_SECURE_NO_WARNINGS #include<iostream> #include<vector> #

從漢諾塔上寫遞歸

from img 調用方法 ret one func create null parent 需求： 求出每一級的數量，但是父級+子級的所有數量。 比如 第一級本身數量為1 而子級是2 ，那麽相加就是3，但是2級還有3級，就需要再加上3級。依次類推到最後一級數量之和就是這

寫遞歸出現的一些問題

public 每次 遞歸 利用 函數 stat 發現 重復 foreach 今天利用遞歸函數獲取指定欄目的全部子欄目，需要遞歸調用，寫的我自己感覺不應該有問題，但是數據重復出現太多次了 後來才發現範了一個二逼錯誤，遞歸調用後又賦值了，導致數據return出現太多 p

函數-遞歸調用

-s 導致 情況 特殊 效果 tro 並且 使用 就會 一、什麽是遞歸調用 遞歸調用：在函數調用過程中，直接或間接地調用了函數本身，這就是函數的遞歸調用1.遞歸的優點 遞歸函數的優點是定義簡單，邏輯清晰。理論上，所有的遞歸函數都可以寫成循環的方式，但循環的邏輯不如遞歸清晰。

Java遞歸調用實例

遞歸調用private int num=0; private String parentCode = null; private String returnCode = null; /** * 查詢頂級外場，如果當前部門的上級部門一直是外場，那就返回最頂層的orgcode,如果一直不是外場，就返回最初的o

譚浩強 c程序設計 8.17用遞歸法將一個整數n轉換成字符串。例如，輸入486，應輸出字符串"486"。n的位數不確定，可以是任意位數的整數。

tco xsl bof hcl mku owb kit gym code 8.17用遞歸法將一個整數n轉換成字符串。例如，輸入486，應輸出字符串"486"。n的位數不確定，可以是任意位數的整數。 #include <stdio.h>char str1[20]

python 3 遞歸調用與二分法

turn print 階段 binary class 效率 clas 技術分享 空間 遞歸調用與二分法 1、遞歸調用 遞歸調用：在調用一個函數的過程中，直接或間接地調用了函數本身. 示例： def age(n): if n == 1: return

用遞歸實現歸並排序（不會呀 不知道哪裏錯了）

clas iostream ges sin ace logs div void 遞歸實現 #include<iostream> using namespace std; #include<vector> #include "Vector.h" v

用遞歸方法計算斐波那契數列（Recursion Fibonacci Python)

n-1 html pri style strong ans rdo 黃金分割 nac 先科普一下什麽叫斐波那契數列，以下內容摘自百度百科： 斐波那契數列（Fibonacci sequence），又稱黃金分割數列、因意大利數學家列昂納多·斐波那契（Leonardoda Fib

用遞歸方法判斷字符串是否是回文（Recursion Palindrome Python)

回文字符 如何 .html ont for level course put 如果 所謂回文字符串，就是一個字符串從左到右讀和從右到左讀是完全一樣的。比如："level" 、“aaabbaaa”、 "madam"、"radar"。 如何判斷字符串是否是回文呢？解決思路如

課程作業03：用遞歸方法計算組合數、解決漢諾塔問題、判斷某個字符串是否回文

java class ply math alt static multi 構造 strong 課後作業1：使用計算機計算組合數 （1）使用組合數公式利用n！來計算 程序設計思想： 設計並調用大數求階乘的方法結合組合數公式計算組合數的值。 程序流程圖： 程序源代碼

用遞歸函數和棧操作逆序棧

alt nbsp 棧操作 深度優先 subject lan -- highlight style 用遞歸函數和棧操作逆序棧 題目描述 一個棧依次壓入1,2,3,4,5那麽從棧頂到棧底分別為5,4,3,2,1。將這個棧轉置後，從棧頂到棧底為1,2,3,4,5，也就是實現了棧

給定程序中函數fun的功能是：用遞歸算法求形參a的平方根。求平方根的叠代公式如下：

square 2.0 double nbsp oot amp math clu print X1=1/2(x0+a/x0) 例如，a為2時，平方根值：1.414214 #include <stdio.h>#include <math.h>doub

如何寫好遞歸算法

二分 csdn div 先後 二叉 一個數 for 能說 區別 什麽叫遞歸？（先定義一個比較簡單的說法，為了理解，不一定對） 　　遞歸：無限調用自身這個函數，每次調用總會改動一個關鍵變量，直到這個關鍵變量達到邊界的時候，不再調用。 比如說我要你先求一個N!的結果 你說

用遞歸方法解決漢諾塔問題（Recursion Hanoi Tower Python）

else tro 如果 strong noi ron 最小 傳說 大小 漢諾塔問題源於印度的一個古老傳說：梵天創造世界的時候做了三根金剛石柱子，在一根柱子上從下往上按照大小順序摞著64片黃金圓盤。梵天命令婆羅門把圓盤按大小順序重新擺放在另一根柱子上，並且規定小圓盤上不能放大

scrapy初試水 day03（遞歸調用）

esp star obj amp result yield 滿足 jobs rom import scrapyfrom scrapy.http import Requestfrom scrapy.spider import Rulefrom scrapy.linkextra

2017年11月30日 C#TreeNode遞歸&郵箱驗證&新用戶窗體

安全證書 event 數據 隨機 false 設置 tex 成功 創建 TreeNode遞歸 遞歸:自己調用自己一層一層的把數據找出來 TreeNode:可以創建多個節點 private void button1_Click(object sender, EventA

bash腳本之函數簡單介紹、應用及函數的簡單遞歸調用

bash腳本bash腳本編程--函數 在bash中，函數是由命令和語句結構構成的能夠實現特定功能的集合； 為什麽要在bash中引入函數？ 在bash腳本編寫過程中有可能會出現重復且不做任何改變的代碼內容，如果這類內容全靠原始代碼書寫的話不易於排錯和優化；因此我們可以選擇將此類代碼封裝在函數中，在適當的場景中可

Python函數中多類型傳值和冗余參數及函數的遞歸調用

rgb {} rgs fun mini eight 分享圖片 not strong 1.多類型傳值和冗余參數多類型傳值： def fun(x,y): return x +y print fun(3,5) 8 print fun(*t)