尋找最小生成樹的歐拉路徑，即一筆畫問題

【程序背景】最近在做子圖匹配的實驗，對查詢圖需要進行預處理，得到最小生成樹，然後進行後續的子圖匹配工作，由於匹配過程是按照順序依次遍歷匹配的，當時程序就卡在尋找一條順序相連的最小生成樹的歐拉路徑問題上了，查了很多關於歐拉路徑的解決方案，覺得過於複雜，乾脆最後自己寫了一個小程序，解決了。

【問題說明】輸入list：（2,6）（1,3）（1,2）（4,5）（1,4）

得到newlist：（4,5）（1,4）（1,3）（1,2）（2,6）

【實驗環境】eclipse+Java

【算法思路】list是最小生成樹，newlist是需要得到順序相連的歐拉路徑，注意最小生成樹一定是連通圖，即一定存在歐拉路徑

 * 第一步--->取list中的第一條邊，遍歷剩餘邊，尋找與該邊相連接的所有邊，add到newList中
 * 第二步--->取list中的剩餘邊edge，與newList中的邊進行比較
 * 1-->如果edge與newlist的第一條邊相連，直接newList.add(0,edge)，在頭插入，然後刪除list中的edge
 * 2-->如果edge與newlist的最後一條邊相連，直接newList.add(edge)，在尾插入，然後刪除list中的edge
 * 3-->如果edge與newlist中間的一條邊相連，先把newlist中的那條邊移動到尾部，再進行插入刪除操作
 * 4-->如果都不相連，去list的下一條邊進行上述操作，直至最後list集合爲空爲止。

【代碼說明】代碼中有一個Edge類--->Edge（CITING，CITED），表示一條邊，專利的引用關係。

public class Edge {
    private String CITING;
    private String CITED;

    public Edge(String CITING,String CITED){
        this.CITING = CITING;
        this.CITED = CITED;
    }

    public String getCITING() {
        return CITING;
    }

    public void setCITING(String cITING) {
        CITING = cITING;
    }

    public String getCITED() {
        return CITED;
    }

    public void setCITED(String cITED) {
        CITED = cITED;
    }

    public boolean equals(Edge obj) {
        // TODO Auto-generated method stub
        String citing = obj.getCITING();
        String cited = obj.getCITED();
        if(CITING.equals(citing)&&CITED.equals(cited))
            return true;
        else
            return false;

    }

    public boolean isExistOf(String str){
        if(str.equals(CITING)||str.equals(CITED))
            return true;
        else
            return false;
    }

    public boolean isLinked(Edge e){
        if(e.getCITING().equals(CITING)||e.getCITING().equals(CITED)||
                e.getCITED().equals(CITING)||e.getCITED().equals(CITED))
            return true;
        else
            return false;
    }

    public String toString(){
        return CITING +" -> "+CITED;
    }
}

【實驗代碼】

import java.util.ArrayList;

/**
 * @author Coraline
 * 算法---尋找最小生成樹的歐拉路徑，即一筆畫問題
 * 遍歷所有的邊僅一次，邊前後相連
 * 算法思路：
 * 第一步--->取list中的第一條邊，遍歷剩餘邊，尋找與該邊相連接的所有邊，add到newList中
 * 第二步--->取list中的剩餘邊edge，與newList中的邊進行比較
 *          1-->如果edge與newlist的第一條邊相連，直接newList.add(0,edge)，在頭插入，然後刪除list中的edge
 *          2-->如果edge與newlist的最後一條邊相連，直接newList.add(edge)，在尾插入，然後刪除list中的edge
 *          3-->如果edge與newlist中間的一條邊相連，先把newlist中的那條邊移動到尾部，再進行插入刪除操作
 *          4-->如果都不相連，去list的下一條邊進行上述操作，直至最後list集合爲空爲止。
 */

public class Main {

    public static void main(String[] args) throws Exception {

        //算法測試數據
        ArrayList<Edge> list = new ArrayList<>();
        list.add(new Edge("2", "6"));
        list.add(new Edge("1", "3"));
        list.add(new Edge("1", "2"));
        list.add(new Edge("4", "5"));
        list.add(new Edge("1", "4"));
        //用於存放重新排序之後的結果集合
        ArrayList<Edge> newlist = new ArrayList<>();

        Edge e1 = list.get(0);
        list.remove(0);
        newlist.add(e1);
        String citing = e1.getCITING();
        String cited = e1.getCITED();

        //第一步，選取第一條邊，取得所有與該邊相連的所有連邊，add到newlist
        for(int i =0;i<list.size();i++){
            if(list.get(i).isExistOf(citing)){
                newlist.add(0,list.get(i));
                list.remove(i);
                i--;
            }
            else if(list.get(i).isExistOf(cited)){
                newlist.add(list.get(i));
                list.remove(i);
                i--;
            }
        }

        System.out.println("newlist");
        for (Edge edge : newlist) {
            System.out.println(edge.toString());
        }

        System.out.println("list");
        for (Edge edge : list) {
            System.out.println(edge.toString());
        }

        //第二步，從剩餘邊中依次進行判斷，有序加入到newlist中
        int point = 0;//設置一個指針，指明當前進行判斷的記錄
        while(!list.isEmpty()){
            e1 = list.get(point);
            citing = e1.getCITING();
            cited = e1.getCITED();
            for(int i =0 ;i<newlist.size();i++){
                //如果list(point)與newlist中的記錄是相連的
                if(newlist.get(i).isExistOf(citing)||newlist.get(i).isExistOf(cited)){
                    //相連的記錄在newlist的頭部，直接在頭部插入
                    if(i == 0){
                        newlist.add(0,e1);
                        list.remove(point);
                        point=-1;//注意指針要回歸到-1
                        break;
                    }
                    //相連的記錄在newlist的尾部，直接在尾部插入
                    else if(i == newlist.size()-1){
                        newlist.add(e1);
                        list.remove(point);
                        point=-1;//注意指針要回歸到-1
                        break;
                    }
                    //相連的記錄不在頭尾的，先調整順序至於尾部，再插入
                    else{
                        newlist.add(newlist.get(i));
                        newlist.remove(i);

                        newlist.add(e1);
                        list.remove(point);
                        point=-1;//注意指針要回歸到-1
                        break;
                    }
                }
            }
            point++;//指針下移，判斷下一個結點
        }

        System.out.println("newlist");
        for (Edge edge : newlist) {
            System.out.println(edge.toString());
        }

        System.out.println("list");
        for (Edge edge : list) {
            System.out.println(edge.toString());
        }

    }

}

【實驗結果】分了兩個步驟的輸出，一個是第一步處理後的輸出，一個是第二步處理後的輸出。

Java 創建二叉樹並遍歷

public class BinaryTree {

    private Node root;

    /**
     *
     * 內部節點類
     * @author yhh
     */
    private class Node{
        private Node left;
        private Node right;
        private int data;
        public Node(int data){
            this.left = null;
            this.right = null;
            this.data = data;
        }
    }

    public BinaryTree(){
        root = null;
    }

    /**
     * 遞歸創建二叉樹
     * @param node
     * @param data
     */
    public void buildTree(Node node,int data){
        if(root == null){
            root = new Node(data);
        }else{
            if(data < node.data){
                if(node.left == null){
                    node.left = new Node(data);
                }else{
                    buildTree(node.left,data);
                }
            }else{
                if(node.right == null){
                    node.right = new Node(data);
                }else{
                    buildTree(node.right,data);
                }
            }
        }
    }

    /**
     * 前序遍歷
     * @param node
     */
    public void preOrder(Node node){
        if(node != null){
            System.out.println(node.data);
            preOrder(node.left);
            preOrder(node.right);
        }
    }

    /**
     * 中序遍歷
     * @param node
     */
    public void inOrder(Node node){
        if(node != null){
            inOrder(node.left);
            System.out.println(node.data);
            inOrder(node.right);
        }
    }

    /**
     * 後序遍歷
     * @param node
     */
    public void postOrder(Node node){
        if(node != null){
            postOrder(node.left);
            postOrder(node.right);
            System.out.println(node.data);
        }
    }

    public static void main(String[] args) {
        int[] a = {2,4,12,45,21,6,111};
        BinaryTree bTree = new BinaryTree();
        for (int i = 0; i < a.length; i++) {
            bTree.buildTree(bTree.root, a[i]);
        }
        bTree.preOrder(bTree.root);
        bTree.inOrder(bTree.root);
        bTree.postOrder(bTree.root);
    }

}