故障樹演算法JAVA實現

故障樹演算法的介紹：

【排版出問題了，代碼請點代碼框上方的view plain查看】

對於圖1這樣一個故障樹的最小割集的計算，我的思路是採用下行法和素數法：

 

圖1 故障樹

 

所謂的下行法基本原理是故障樹中的或門增加割集數目，與門增加割集的容量。從故障樹的頂事件開始，由上到下，順次把上一級事件置換為下一級事件，遇到與門就將輸入事件橫向並列寫出，遇到或門就將輸入事件豎向串聯寫出，直到把全部邏輯門都置換成底事件為止，此時最後一列代表所有割集，割集吸收得到最小割集採用素數法，其思想就是給每個底事件賦一素數，割集相除去掉能作為被除數的割集，從而得到最小割集。這部分實現起來比較容易，不做深入講解。具體分析步驟如表1所示：

 

                         表1 最小割集分析步驟

 

以下是一些對於儲存資料的一些定義，在一個執行個體中的運算過程【這是後來編輯的，之前看的朋友不好意思了】

【我就不明白了CSDN這編輯功能怎麼這麼爛】190-380行手動編輯的，還出問題，要瘋了。。。

不想整了，直接上傳了源碼，連結【http://download.csdn.net/detail/conquerwave/5713163】注釋亂碼了，參考下文的源碼

 

 

 

/* * To change this template, choose Tools | Templates * and open the template in the editor. * author: inmen.wang * mail: hugewave@yeah.net * build date: 2012.11.25 * last edit: 2012.11.27 */package mytree;/** * * @author Inmen *//************************************當前類中所需被外部調用的函數MyTree()   初始化本類,為各資料分配空間setSubTree()   傳遞處理所需參數給本對象setLabelname()  傳遞處理所需參數給本對象setTreeMap()   傳遞處理所需參數給本對象getFAT()     擷取處理後的最小割集getFAT_n()     擷取處理後的最小割集個數 ************************************/public class MyTree {    //private static int counter = 0;    private static int subtree;        // 儲存有多少個子樹    private static String[] label = new String[100];      // 對應該節點名稱      private static int[][] treemap = new int[100][50];       // 儲存樹的對應關係    private static int[][] subnode = new int[500][100];       // 儲存所有割集，不去除重複，不用素數法去除    private static int[][] middletable = new int[100][20];    private static int middletable_n;    private static int subnode_n;                                //記錄相對應（subnode）割集數    private static int [][] subnode_sole = new int[400][20];       // 儲存所有割集，去除重複，不用素數法去除    private static int subnode_sole_n;                                //記錄相對應（subnode_sole）割集數    private static int[][] subnode_result = new int[300][20];       // 儲存所有割集，最張結果    private static int subnode_result_n;                                //記錄相對應（subnode_result）割集數    private static int[][] subnode_ouput = new int [100][50];    private static int subnode_output_n;    private static int[] prime = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47};            /**     * @param args the command line arguments     */    public static void main(String[] args) {        /*********************************************************************************************************         * 樣本資料         *        int subt = 13;        int[][] tree;        tree = new int[][]{{2, -1, 1, 11},       // 0                           {3, -2, 2, 3, 4},     // 1                           {2, -1, 5, 6},        // 2                           {2, -1, 7, 8},        // 3                           {2, -1, 9, 10},       // 4                           {0, 0},              // 5                           {0, 0},              // 6                           {0, 0},              // 7                           {0, 0},              // 8                           {0, 0},              // 9                           {0, 0},              // 10                           {2, -2, 12, 13},      // 11                           {0, 0},              // 12                           {0, 0}};             // 13        String[] lab = new String[]{"T", "H2", "H4", "H5", "H6", "X7", "X2", "X7", "X3", "X2", "X3", "H3", "X4", "X5"};        /*************************************the end 樣本資料****************************************************/        /***************************************/        int subt = 14;        int[][] tree;        tree = new int[][]{{2, -1, 1, 10},       // 0                           {2, -2, 2, 3},     // 1                           {2, -1, 4, 5},        // 2                           {2, -1, 6, 7},        // 3                           {0, 0},       // 4                           {2, -2, 8, 9},              // 5                           {0, 0},              // 6                           {0, 0},              // 7                           {0, 0},              // 8                           {0, 0},              // 9                           {2, -2, 11, 12},              // 10                           {2, -1, 13, 14},      // 11                           {0, 0},              // 12                           {0, 0},  // 13                           {0, 0}};// 14                   String[] lab = new String[]{"T", "E1", "E3", "E4", "B2", "E6", "B3", "B7", "B8", "E2", "E5", "B1", "B5", "B6"};        //*/                MyTree.getSubTree(subt);        MyTree.getLabel(lab);        MyTree.getTreeMap(tree);            // 顯示儲存的故障樹            for(int i = 0; i <= subt; i ++)            {               for(int j = 0; j<=MyTree.treemap[i][0]+1; j++)               {                   System.out.print(MyTree.treemap[i][j]+" ");               }               System.out.println();            }            System.out.println("******************************");            //calLayer();            MyTree.getAllSubNode();            buildupMiddleTable();            MyTree.cutRepet();            MyTree.getEnd();        //System.out.println(subtree);    }    /*********************************************    函數功能:初始化本類後,擷取處理需要的參數    傳參:subt所有事件的個數,包含頂事件,從0開始計數    返回:無    *********************************************/    public static void getSubTree(int subt) {        MyTree.subtree = subt;    }    /**********************************************    函數功能:初始化本類後,擷取處理所需的事件名稱                            用於消除相同事件    傳參:lab[] 字串數組,數組中編號對應事件名稱    返回:無    **********************************************/    public static void getLabel(String[] lab){        for(int i = 0; i < lab.length; i ++)        {            MyTree.label[i] = lab[i];        }    }    /**********************************************    函數功能:初始化本類後,擷取處理所需樹的結構         用於計算獲得最小割集    傳參:tree[][] 二維整型數組,儲存樹的結構關係    返回:無    **********************************************/    public static void getTreeMap(int[][] tree)    {        for (int i = 0; i < tree.length; i++) {            for(int j = 0; j <= tree[i][0]+1; j ++)            {                MyTree.treemap[i][j] = tree[i][j];            }                    }    }    private static void getAllSubNode(){        MyTree.calculateAllSubNode(treemap[0]);        printArray(subnode, subnode_n, 5);    }    /***********************************     * 計算出所有最小割集並存入subnode[][]數組     * */    private static void calculateAllSubNode(int[] arr){        int position = feedbackPosition(arr);        int men_p = position+1;        int new_position = position;        int length = getMyArrayLength(arr);        if(position == length)        // 如果當前位置和數組長度相等，則說明數組中已經沒有門記號        {            printArray1V(arr, 0, length+1);                 subnode[subnode_n][0] = length+1;            MyTree.copyArray1V(arr, 0, length+1, subnode[subnode_n++], 1);        }        else if(arr[men_p]==-1)         // or        {            // 如果門記號為或門則需要對每個符號建立新的數組            for(int i = men_p+1; i <= men_p +arr[position]; i ++)            {                int[] array = new int[100];                MyTree.copyArray1V(arr, 0, position-1, array, 0);                /*                 *此處略去處理過程,因為是外包的代碼，保密                 */                 MyTree.copyArray1V(arr, position+arr[position]+2, length-position-arr[position]-2, array, new_position);                calculateAllSubNode(array);            }        }        else if(arr[men_p] == -2)  // and        {            int[] array = new int[100];            MyTree.copyArray1V(arr, 0, position-1, array, 0);            
                /*                 *此處略去處理過程,因為是外包的代碼，保密                 */
 MyTree.copyArray1V(arr, position+arr[position]+2, length-position-arr[position]-2, array, new_position); calculateAllSubNode(array); } }
private static void buildupMiddleTable(){ 
int[] temp = new int[label.length]; 
for(int i = 1; i <= subtree; i ++) { 
if(treemap[i][0] == 0) // 後續無節點，則判斷此末節點是否需要存入middletable 
{ 
// 
if(temp[i] == 0) //檢察名字是否已經存在於middletable中, 不存在則另起一行存入 
{ 
middletable[middletable_n][0] ++; 
middletable[middletable_n][middletable[middletable_n][0]] = i; 
temp[i] = 1; 
for(int j = 0; j < subtree; j ++) 
// 如果是本身則向後移一個單位 
{ 
if(i == j) // 如果是本身則向後移一個單位 
{ 
j++; 
} //
int len = label.length; 
if(j<subtree) // 判斷是否超出數組長度 
{ //int tt = compareStr(label[i], label[j]) == 0 
if(label[i]==label[j] && temp[j] == 0) { 
middletable[middletable_n][0] ++; 
middletable[middletable_n][middletable[middletable_n][0]] = j; 
//middletable_n++; 
temp[j] = 1; 
} 
} 
} 
middletable_n++; 
} 
} 
} 
// 添加素數和行號 
for(int i = 0; i < middletable_n; i ++) { 
middletable[i][middletable[i][0]+1] = prime[i]; 
middletable[i][middletable[i][0]+2] = i; 
} printArray(middletable, middletable_n, 5); } 
/*************************************** * 去除重複割集，並存入subnode_sole[][]數組 * * ************************************/
 private static void cutRepet(){ 
// 利用middletable替換不同編號的相同項 
//int tempflag[][] = new int[subnode_n][50]; 
// the number 50 maybe need changed 
for(int i = 0; i < subnode_n; i ++) { 
// 第0列直接拷貝過來 
subnode_sole[i][0] = subnode[i][0]; 
for(int j = 1; j <= subnode[i][0]; j++) { 
int tempflag = 0; 
for(int k = 0; k <middletable_n;k++) { // 判斷當前編號是否是在buildtable中的第1列 
if(subnode[i][j] == middletable[k][1]) // 在第1列則不用替換 
{ 
tempflag = 1; 
} 
} 
if(tempflag == 0) // 如果不是第1列則需要尋找存在於第幾行中 
{ 
for(int m = 0; m < middletable_n; m ++) { 
for(int n = 2; n <= middletable[m][0]; n ++) { 
if(subnode[i][j] == middletable[m][n]) { 
subnode_sole[i][j]= middletable[m][1]; n = middletable[m][0]; 
} 
} 
} 
} 
else // 如果不是第1列則需要替換 { 
subnode_sole[i][j] = subnode[i][j]; 
} 
} 
} 
subnode_sole_n = subnode_n; 
//printArray(subnode_sole, subnode_sole_n, 5); 
// 消除一行中的重複項 
for(int i = 0 ; i < subnode_sole_n; i ++) 
{ 
for (int j = 1; j < subnode_sole[i][0]; j++) 
{ 
for(int k = j+1; k <= subnode_sole[i][0]; k ++) 
{ 
if(subnode_sole[i][j] == subnode_sole[i][k] && subnode_sole[i][k] != -1) 
{ 
subnode_sole[i][k] = -1; 
} 
} 
} 
for(int j = 1; j < subnode_sole[i][0]; j ++) 
{ 
int k = j+1; 
if(subnode_sole[i][j] == -1) 
{ 
if(subnode_sole[i][k] != -1) 
{ 
subnode_sole[i][j] = subnode_sole[i][k]; 
subnode_sole[i][k] = -1; 
subnode_sole[i][0]--; 
} 
else 
{ 
k++; 
} 
} 
} 
if(subnode_sole[i][subnode_sole[i][0]] == -1) 
{ 
subnode_sole[i][0] --; 
} 
} 
//printArray(subnode_sole, subnode_sole_n, 5); 
// 行排序 
for(int i = 0; i < subnode_sole_n; i ++) 
{ 
for(int j = 0; j < subnode_sole[i][0]; j++) 
{ 
for(int k = 1; k < subnode_sole[i][0]; k ++) 
{ 
if(subnode_sole[i][k]>subnode_sole[i][k+1]) 
{ 
int temp= subnode_sole[i][k+1]; 
subnode_sole[i][k+1] = subnode_sole[i][k]; 
subnode_sole[i][k] = temp; 
} 
} 
} 
} 
// 消除相同行 
for(int i = 0; i <subnode_sole_n-1; i ++) 
{ 
for(int j = i+1; j < subnode_sole_n; j++) 
{ 
int temp = compareArray(subnode_sole[i], subnode_sole[i][0], subnode_sole[j], subnode_sole[j][0]);
if( temp == 0 && subnode_sole[i][0]!=0) 
{ 
subnode_sole[j][0] = 0; 
} 
} 
} 
for(int i = 0; i < subnode_sole_n; i ++) 
{ 
if(subnode_sole[i][0]!=0) 
{ 
for(int j = 0; j <= subnode_sole[i][0]; j++) 
{ 
subnode_result[subnode_result_n][j] =subnode_sole[i][j]; 
} 
subnode_result_n++; 
} 
} 
//printArray(subnode_sole, subnode_sole_n, 5); 
printArray(subnode_result, subnode_result_n, 5); 
} 
/******************************************* * 用素數法，獲得最終割集並存入subnode_result[][]數組 * **************************************/
、private static void getEnd(){ 
// 產生映射隊列 防止編號過大，素數數量不夠用 
int[] map= new int[200]; 
int number = 0; 
for(int i = 0; i < subnode_result_n; i ++) 
{ 
for(int j = 1; j <= subnode_result[i][0]; j++) 
{ 
if(map[subnode_result[i][j]] ==0) 
{ 
map[subnode_result[i][j]] = number; number++; 
} 
} 
} 
for(int i = 0; i < subnode_result_n; i ++) 
{ 
int multi = 1; 
for(int j = 1; j <= subnode_result[i][0]; j ++) 
{ 
multi *= prime[map[subnode_result[i][j]]]; 
} 
subnode_result[i][subnode_result[i][0]+1] = multi; 
} // 消除能非最小時素數積項
                /*                 *此處略去處理過程,因為是外包的代碼，保密                 */             printArray(subnode_result, subnode_result_n, 5);        subnode_output_n = 0;        for(int i = 0;i < subnode_result_n; i ++)        {            if(subnode_result[i][0] != 0)            {                for(int j = 0;j <= subnode_result[i][0]; j ++)                {                    subnode_ouput[subnode_output_n][j] = subnode_result[i][j];                }                subnode_output_n ++;            }        }        printArray(subnode_ouput, subnode_output_n, 5);    }            private static void printArray(int[][] arr, int x, int y){        for(int i = 0; i < x; i ++)        {            for(int j = 0; j < y; j ++)            {                System.out.print(arr[i][j]+" ");            }            System.out.println();        }        System.out.println("******************************");    }    /*     * 從數組str1 sx1起拷備長度為len到str2 從sx2起     */    private static void copyArray1V(int[] str1, int sx1, int len, int[] str2, int sx2)    {            //for(int i = sx1; i <= sx1+len; i++)            for(int i = 0; i <= len; i++)            {                str2[sx2+i] = str1[sx1+i];            }    }      /*     * example : array as 2 -1 1 11     * return 3     */    private static int getMyArrayLength(int[] myarr){        int i = 0;        //while（myarr[i] != 0)        while (myarr[i] != 0) {              i ++;        }        return i-1;        }    /*     * example: array as 2 -1 1 11     * return 0     *          array as 2 2 12 13     * return 3     * 位置定位為數組中第一個門記號位置前一位     */    private static int feedbackPosition(int[] arr){        int i = 0;        while (arr[i]>0 && arr[i]!= 0) {                        i++;        }        return i-1;    }              /*     * if same return 0     * else return 1     */    private static int compareArray(int[] str1, int len1, int[] str2, int len2)    {        if(len1 != len2)        {            return 1;        }        else        {            for(int i = 0;i <= len1; i ++)            {                if(str1[i] != str2[i])                {                    return 1;                }            }        }        return 0;    }    private static void printArray1V(int[] arr, int st, int len){        for(int i = st; i < len+st; i ++)        {            System.out.print(arr[i]+ " ");        }        System.out.println("***************");    }}