寻找最小生成树的欧拉路径，即一笔画问题

【程序背景】最近在做子图匹配的实验，对查询图需要进行预处理，得到最小生成树，然后进行后续的子图匹配工作，由于匹配过程是按照顺序依次遍历匹配的，当时程序就卡在寻找一条顺序相连的最小生成树的欧拉路径问题上了，查了很多关于欧拉路径的解决方案，觉得过于复杂，干脆最后自己写了一个小程序，解决了。

【问题说明】输入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);
    }

}