一个别人问我的多叉树的问题....

问题描述：

这是她的项目里的一个需求好像要做什么聚类的，但是我不太懂，只是用我的思路解决了问题...

输入:

一个字符串数组，数组中的每个字符串的格式为A B,AB中间有一个空格，A和B是源IP和目的IP.

输出:

输出所有的A B B C C D形式的串，即数组中的字符串的后半部分和另一个字符串的前半部分相同的话就要成一条链,但是扫描到一个字符串的时候不用考虑他前面串是否满足该特性.

我的思路：

这个问题可以用多叉树来做，为每一个根结点创建一个树(用哈希表防止重复建树和关键节点，这个很重要)，读入数组后根据条件建立一个多叉树，然后用深度优先搜索遍历并保存每一条路径，就是要的结果,时间复杂度为O(n2)，应该还有更好的方案，但是我智商捉急，只能想到O(n2)复杂度的算法，另外二叉树的深度优先非递归写法在保存路径时节点回退我没有想到解决方案，就改写成了递归方法，否则可以用一个栈来做.

借用数据结构:

HashMap:根据字符串的值来当哈希键值，用来存储一个串的节点是否被访问过，以防止多建了树。

Stack:非递归深搜二叉树的时候要用到.

package help.myz;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Stack;




class MultiTreeNode
{//多叉树
    //MultiTreeNode parent = null; //父节点，为了扫描树深搜回退节点的去除字符串的时候用
    String str = null;//当前字符串的值
    //boolean isIntree = false; //标志该节点是否已经被填入到一颗树中，如果添加到过就不用添加了
    
    ArrayList<MultiTreeNode> childList = new ArrayList<>();//所有的孩子节点
    public MultiTreeNode(String str) {
        // TODO Auto-generated constructor stub
        this.str = str;
    }
}

public class MultiTree {
    
    ArrayList<MultiTreeNode> treeList = new ArrayList<>(); //存储所有的树
    HashMap<String, MultiTreeNode> treeMap = new HashMap<>(); //记录字符串是否被扫描过
    
    ArrayList<String> tmpStrList = new ArrayList<>(); //存储扫描树的某条路径时过程中的中间串
    
    public void treeBuild(ArrayList<String> strlist)
    {
        int index = 0,i;
        for(i = 0; i < strlist.size(); i++)
        {
            String currentString = strlist.get(i);
            MultiTreeNode currentNode = treeMap.get(currentString);
            
            if(currentNode == null)
            {
                //System.out.print("build a tree");
                currentNode = new MultiTreeNode(currentString);//创建新的节点
                treeMap.put(currentString, currentNode); //把当前节点加入到哈希表
                treeList.add(currentNode); //让该节点重新创建一颗树
            }
            
            /*更新树，查找当前节点后面的节点是否有其后续链*/
            index  = i + 1;
            for(; index < strlist.size(); index++)
            {
                String strBack = currentString.split(" +")[1];//获取字符串的后半部分
                String strForward = strlist.get(index).split(" +")[0];//获取字符串的前半部分
                
                if(strBack.equals(strForward))
                {//该节点满足条件AB BC
                    MultiTreeNode childNode = new MultiTreeNode(strlist.get(index));//创建新字符串的孩子节点
                    treeMap.put(strlist.get(index), childNode);//将扫描到的当前孩子节点也加入哈希表,防止二次建树
                    
                    currentNode.childList.add(childNode);//给当前树的当前节点添加孩子节点
                }
            }
        }
    
    }
    
    /*
     *递归深度优先遍历树，并生成路径 
     */
    public void treeScan_ReCursion(MultiTreeNode root)
    {
        this.tmpStrList.add(root.str);//将当前字符串加入临时存储表
        
        if(root.childList.size() == 0)
        {//当前节点为叶子节点，扫描完一条路径，保存该路径
            ArrayList<String> pathStrList = new ArrayList<>(this.tmpStrList);
            
            PrintPathList(pathStrList);
            //PrintPathList(tmpStrList);
        }
        
        for(int i = 0; i < root.childList.size(); i++)
        {//递归扫描所有孩子节点
            treeScan_ReCursion(root.childList.get(i));
        }
        
        this.tmpStrList.remove(this.tmpStrList.size() - 1);//节点回退上一层的时，回退一个字符串
    }
    
    /*
     * 非递归深度优先遍历当前树，并生成路径
     */
    /*
    public void treeScan(MultiTreeNode root)
    {
        ArrayList<String> tmpList = new ArrayList<>();//存储深搜的过程值
        
        Stack<MultiTreeNode> treeStack = new Stack<>();
        
        treeStack.add(root);
        
        while(!treeStack.isEmpty())
        {//当前树未扫描完
            MultiTreeNode currentNode = treeStack.pop(); //获取栈顶值
            int nodeChildNum = currentNode.childList.size();
            tmpList.add(currentNode.str);//将当前的字符串加入中间结果
            
            if(nodeChildNum == 0)
            {//当前节点为叶子节点
                ArrayList<String> currentStrList = new ArrayList<>(tmpList);//存储当前扫描完的一条路径的串
                //System.out.println(currentStrList);//打印当前链 
                PrintPathList(currentStrList);
                tmpList.remove(tmpList.size() - 1); //回退一个字符串,为了继续搜索其他路径
            }
            
            
            if(currentNode.parent != null)
            {//父节点不为空
                ArrayList<MultiTreeNode> brotherList = currentNode.parent.childList;//所有的兄弟节点链表
                MultiTreeNode finalBrotherNode = brotherList.get(brotherList.size() - 1);//获取当前节点的最后一个兄弟节点
                if(currentNode == finalBrotherNode)
                {//访问完当前层的最后一个节点，还需要回退一个节点
                    tmpList.remove(tmpList.size() - 1);
                }
            }
            
            
            for(int i = nodeChildNum - 1; i >= 0; i--)
            {
                treeStack.push(currentNode.childList.get(i)); //将其他孩子按照从后到前的顺序入栈
            }
            
        }
    }
    */
    
    /*
     *扫描所有树 
     */
    public void treeListScan()
    {//将所有树扫描出来
        for(int i = 0; i < treeList.size(); i++)
        {
            MultiTreeNode treeRoot = treeList.get(i); //获取当前树的根
            //treeScan(treeRoot);
            treeScan_ReCursion(treeRoot);
        }
    }
    
    public void PrintPathList(ArrayList<String> pathStrList)
    {
        for(int i = 0; i < pathStrList.size(); i++)
        {
            System.out.print(pathStrList.get(i) + "-->");
        }
        
        System.out.println();
        System.out.println("--------------------------");
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MultiTree multiTree = new MultiTree();
        String strArray[] = {
                "2886758962 2886758450",
                "2886758450 2886759119",
                "2886758962 2886758607",
                "2886758962 2886758740",
                "2886758450 2886759080",
                "2886758962 2886758500",
                "2886758607 2886758500",
                "2886758962 2886758594",
                "2886758450 2886758594",
                "2886758450 2886759081",
                "2886758962 2886759081",
                "2886758450 2886758860",
                "2886758450 3290778526",
                "2886758607 3290778526",
                "2886759060 3290778526",
                "2886759119 3290778526",
                "2886758450 2886758549",
                "2886758500 2886758420",
                "2886758962 2886758706",
                "2886758420 2886758706",
                "2886758594 2886758706",
                "2886758500 2886758706",
                "2886758740 2886758706"
                };
        
        String strArray2[] = {
                "A B",
                "B C",
                "C D",
                "A E",
                "B F",
                "D K"
        };
        
        ArrayList<String> strlist = new ArrayList<>();
        
        for(int i = 0; i < strArray.length; i++)
        {
            strlist.add(strArray[i]);
        }
        
        multiTree.treeBuild(strlist);
        //System.out.println("treeNum is " + multiTree.treeList.size());
        multiTree.treeListScan();
    }

}