[博图][排序]利用二叉树算法 顺序,降序..数组排序...最低功耗算法.容易调用...

Function

"LSOR" SORTING BLOCK

　　　　1 : Ascending
　　　　-1: Descending

Example

['4','1','9','8','2','10','3','7','6','5'] => ['1','2','3','4','5','6','7','8','9','10']//Ascending 

['4','1','9','8','2','10','3','7','6','5'] => ['10','9','8','7','6','5','4','3','2','1']//Descending 

Input 

Output

InOut

Static

　　sList Array[0..999] of Int
　　LSOR_Instance "LSOR"
　　sUList Struct
　　　　CNT Int
　　　　STA_POS Int

Temp

Constant 

 Programming

#sUList.CNT := 30;//length of list 

#LSOR_Instance(IAZ := 1,//1: ascending -1: descending 
               ULIS := #sUList,//structure of list 
               ALIS := #sList);//arrays of list 

 

 Result

 

#sUList.CNT := 30;//length of list 

#LSOR_Instance(IAZ := -1,//1: ascending -1: descending 
               ULIS := #sUList,//structure of list 
               ALIS := #sList);//arrays of list 

 Library

 "LSOR" SORTING BLOCK

　　　　1 : Ascending
　　　　-1: Descending

Input 

　　IAZ Int 1

Output

InOut

　　ULIS "ULIS"
　　ALIS Array[*] of Int

Temp

　　TMOD Int
　　TI Int
　　TILR Int
　　TINX_END Int
　　TMP Int
　　TOFS_ACT Struct
　　　　LEF Bool
　　　　RIG Bool
　　T0_INX Int
　　T1_INX Int
　　TINX Int

Constant

Return

#TMOD := 2;

IF #ULIS.CNT >= #TMOD THEN
    #TOFS_ACT.LEF := TRUE;
    #TOFS_ACT.RIG := TRUE;
    
    "LGET_ENC_NEX_INX"(MOL_STA_ADR := 0,
                       POI_INX := #ULIS.STA_POS,
                       NEX_INX := 0,
                       LEN := #ULIS.CNT,
                       MOL_NEX_INX => #T0_INX);
    "LGET_ENC_NEX_INX"(MOL_STA_ADR := 0,
                       POI_INX := #ULIS.STA_POS,
                       NEX_INX := 1,
                       LEN := #ULIS.CNT,
                       MOL_NEX_INX => #T1_INX);
    
    FOR #TI := #ULIS.CNT - 1 TO #TMOD BY -1 DO
        FOR #TILR := 0 TO 1 DO
            IF #TI MOD #TMOD = 1 THEN
                #TINX_END := #TI - #TI MOD #TMOD;
            ELSE
                #TINX_END := #TI - #TMOD * #TILR;
            END_IF;
            
            IF #TOFS_ACT.LEF AND ABS(#TI MOD #TMOD - #TILR) = 0 OR #TOFS_ACT.RIG AND ABS(#TI MOD #TMOD - #TILR) = 1 THEN
                "LBUB"(IOFS := ABS(#TI MOD #TMOD - #TILR),
                       IINX_END := #TINX_END,
                       IMOD := #TMOD,
                       IAZ := #IAZ,
                       ULIS := #ULIS,
                       ALIS := #ALIS);
            END_IF;
        END_FOR;

        "LGET_ENC_NEX_INX"(MOL_STA_ADR := 0,
                           POI_INX := #ULIS.STA_POS,
                           NEX_INX := #TI,
                           LEN := #ULIS.CNT,
                           MOL_NEX_INX => #TINX);
        
        IF #IAZ * #ALIS[#T1_INX] > #IAZ * #ALIS[#T0_INX] THEN
            #TMP := #ALIS[#TINX];
            #ALIS[#TINX] := #ALIS[#T1_INX];
            #ALIS[#T1_INX] := #TMP;
            
            #TOFS_ACT.LEF := FALSE;
            #TOFS_ACT.RIG := TRUE;
        ELSE
            #TMP := #ALIS[#TINX];
            #ALIS[#TINX] := #ALIS[#T0_INX];
            #ALIS[#T0_INX] := #TMP;
            
            #TOFS_ACT.LEF := TRUE;
            #TOFS_ACT.RIG := FALSE;
        END_IF;
    END_FOR;
    
    IF #IAZ * #ALIS[#T0_INX] > #IAZ * #ALIS[#T1_INX] THEN
        #TMP := #ALIS[#T1_INX];
        #ALIS[#T1_INX] := #ALIS[#T0_INX];
        #ALIS[#T0_INX] := #TMP;
    END_IF;
END_IF;

 

"LBUB" Drop the ascending /descending value to the top

Input
　　IOFS Int 0
　　IINX_END Int 28
IMOD Int 2
　　IAZ Int 1: ascending -1: descending
Output

InOut
　　ULIS "ULIS"
　　ALIS Array[*] of Int
　　Temp
　　TLAY_I Int
　　TNOD_I Int
　　TNEX_I Int
　　TLAY_I_END Int
　　TNOD_I_END Int
　　TNEX_I_END Int
　　TPVAL Int
　　TINX Int
　　TPINX Int
　　TINX_OFS Int
　　TPINX_OFS Int
Constant

Return
LBUB Void

"LINX_NOD"(IOFS := #IOFS,
           IMOD := #IMOD,
           IINX := #IINX_END,
           OLAY => #TLAY_I_END,
           ONOD => #TNOD_I_END,
           ONEX => #TNEX_I_END);

FOR #TLAY_I := #TLAY_I_END TO 1 BY -1 DO
    FOR #TNOD_I := #TNOD_I_END TO  0 BY -1 DO
        FOR #TNEX_I := #TNEX_I_END TO 0 BY -1 DO
            "LNOD_INX"(IOFS := #IOFS,
                       IMOD := #IMOD,
                       ILAY := #TLAY_I,
                       INOD := #TNOD_I,
                       INEX := #TNEX_I,
                       OINX => #TINX);
            
            "LNOD_PAR"(IOFS := #IOFS,
                       IMOD := #IMOD,
                       ILAY := #TLAY_I,
                       INOD := #TNOD_I,
                       OPAR_INX => #TPINX);
            
            "LGET_ENC_NEX_INX"(MOL_STA_ADR := 0,
                               POI_INX := #ULIS.STA_POS,
                               NEX_INX := #TINX,
                               LEN := #ULIS.CNT,
                               MOL_NEX_INX => #TINX_OFS);
            
            "LGET_ENC_NEX_INX"(MOL_STA_ADR := 0,
                               POI_INX := #ULIS.STA_POS,
                               NEX_INX := #TPINX,
                               LEN := #ULIS.CNT,
                               MOL_NEX_INX => #TPINX_OFS);
            
            IF #IAZ * #ALIS[#TINX_OFS] > #IAZ * #ALIS[#TPINX_OFS] THEN
                #TPVAL := #ALIS[#TPINX];
                #ALIS[#TPINX_OFS] := #ALIS[#TINX_OFS];
                #ALIS[#TINX_OFS] := #TPVAL;
            END_IF;
        END_FOR;
        #TNEX_I_END := 1;
    END_FOR;
    "LTRE_MAX"(ILAY := #TLAY_I - 1,
               ONOD_MAX => #TNOD_I_END);
END_FOR;

"LINX_NOD"Index of number change to tree node 

Input
　　IMOD Int 2
　　IINX Int INDEX
Output
　　OLAY Int 0..X LAYER
　　ONOD Int NODE NUMBER
　　ONEX Int NEXT
InOut

Temp
　　TINX Int
　　TI Int
　　TLAY_CAL Int
　　TNOD_CAL Int
　　TVAL_CAL Int
Constant

Return
LINX_NOD Void

 

#TINX := #IINX - #IINX MOD #IMOD + #IMOD;

#TI := 0;
#TLAY_CAL := 1;

WHILE #TLAY_CAL <= #TINX DO
    #TI := #TI + 1;
    #TLAY_CAL := REAL_TO_INT(IN := 2 ** INT_TO_REAL(IN := #TI)) * #IMOD;
END_WHILE;

#OLAY := #TI - 1;

#TNOD_CAL := #IINX - (REAL_TO_INT(IN := 2 ** INT_TO_REAL(IN := #OLAY)) - 1) * #IMOD;
#ONOD := (#TNOD_CAL - (#TNOD_CAL MOD 2 * #IMOD)) / (2 * #IMOD);

#ONEX := (#TNOD_CAL / #IMOD) MOD 2;

"LNOD_INX"Tree node change to index of number 

 Input 

　　IOFS Int OFFSET
　　IMOD Int
　　ILAY Int 0..X LAYER
　　INOD Int NODE NUMBER
　　INEX Int NEXT
Output
　　OINX Int
InOut

Temp

Constant

Return
LNOD_INX Void

 

#OINX := (REAL_TO_INT(IN := 2 ** INT_TO_REAL(IN := #ILAY)) +
#INOD * 2 +
#INEX - 1) * #IMOD +
#IOFS;

"LNOD_MAX"Tree layer to max node number 

Input
　　ILAY Int 0..X LAYER
Output
　　ONOD_MAX Int
InOut

Temp

Constant

Return
LNOD_MAX Void

#ONOD_MAX := REAL_TO_INT(IN := 2 ** INT_TO_REAL(IN := #ILAY)) / 2 - 1;

"LNOD_PAR"Node number to parent node 

 Input 

　　IOFS Int OFFSET
　　IMOD Int
　　ILAY Int 0..X LAYER
　　INOD Int NODE NUMBER
Output
　　OPAR_INX Int PARENT INDEX
InOut

Temp

Constant

Return
LNOD_PAR Void

 

#OPAR_INX := (REAL_TO_INT(IN := 2 ** INT_TO_REAL(IN := #ILAY - 1)) +
#INOD - 1) * #IMOD + #IOFS;

"LGET_ENC_NEX_INX"Get index of arrays by offset 

 Input 

　　MOL_STA_ADR Int
　　POI_INX Int
　　NEX_INX Int
　　LEN Int
Output
　　MOL_NEX_INX Int
InOut

Temp
　　TNEX_INX Int
Constant

Return
LGET_ENC_NEX_INX Void

 

#TNEX_INX := (#POI_INX + #NEX_INX) MOD #LEN;

#MOL_NEX_INX := #MOL_STA_ADR + #TNEX_INX;

UDT: 

 ULIS

　　CNT Int
　　STA_POS Int

 Video