通用数据结构树—Java语言实现

树是一种常见的数据结构，得到了非常广泛的应用如文件系统、目录结构、霍夫曼编码等。根据树的特点及应用场景，我们通常会遇到二叉树、平衡树、红黑树、竞赛树、B树等。

在C、C++语言中我们在实现树时需要用到指针，如在二叉树中，我们会用指针指向左子树和右子树。在Java语言中并没有指针，但道理是类似的，我们使用对象来引用左子树和右子树。

下面是自己闲来无事时用Java语言实现的树，这不是一棵二叉树，而是一棵普通的树。提供了树了创建、层次遍历、查找等基本方法。

1.NodeData 是树中的节点或叶子存储的数据内容，可进行随意扩展

package com.eyecm.tree;

/**
 * 树上每个节点存放的数据
 * 
 */
public class NodeData
{
    private String username;
    private String content;

    public NodeData()
    {

    }

    public NodeData(String username, String content)
    {
        this.username = username;
        this.content = content;
    }

    public void output()
    {
        System.out.println(username + " " + content);
    }
}

2.TredNode 是树的节点或叶子的抽象，提供层次遍历、查找等操作

package com.eyecm.tree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

/**
 * 树的节点
 * 
 */
public class TreeNode
{
    private int id;
    private TreeNode parent;
    private ArrayList<TreeNode> children;
    private NodeData data;

    public TreeNode(int id, TreeNode parent, ArrayList<TreeNode> children,
            NodeData data)
    {
        super();
        this.id = id;
        this.parent = parent;
        this.children = children;
        this.data = data;
    }

    public int getId()
    {
        return id;
    }

    public void setId(int id)
    {
        this.id = id;
    }

    public TreeNode getParent()
    {
        return parent;
    }

    public void setParent(TreeNode parent)
    {
        this.parent = parent;
    }

    public ArrayList<TreeNode> getChildren()
    {
        return children;
    }

    public void setChildren(ArrayList<TreeNode> children)
    {
        this.children = children;
    }

    public NodeData getData()
    {
        return data;
    }

    public void setData(NodeData data)
    {
        this.data = data;
    }

    /**
     * 当前节点是否是根节点
     * 
     * @return
     */
    public boolean isRoot()
    {
        if (this.parent == null)
        {
            return true;
        } else
        {
            return false;
        }
    }

    /**
     * 当前节点是否是叶子节点
     * 
     * @return
     */
    public boolean isLeaf()
    {
        if (this.children == null || this.children.size() == 0)
        {
            return true;
        } else
        {
            return false;
        }
    }

    /**
     * 对该节点及其子树进行层次遍历
     * 
     * @param treeNode
     */
    public static void levelTraversal(TreeNode treeNode)
    {
        if (treeNode == null)
        {
            return;
        }
        if (treeNode.isLeaf())
        {
            treeNode.data.output();
        } else
        {
            Queue<TreeNode> queue = new LinkedList<TreeNode>();
            queue.offer(treeNode);
            while (queue.size() > 0)
            {
                TreeNode node = queue.poll();
                node.data.output();

                if (node.isLeaf() == false)
                {
                    for (int i = 0; i < node.children.size(); i++)
                    {
                        queue.offer(node.children.get(i));
                    }
                }
            }
        }
    }

    /**
     * 查找特点的节点，在此使用层次遍历进行查找
     * 
     * @param id
     * @param treeNode
     * @return
     */
    public static TreeNode search(int id, TreeNode treeNode)
    {
        if (treeNode == null)
        {
            return null;
        }
        if (treeNode.isLeaf())
        {
            if (treeNode.id == id)
            {
                return treeNode;
            } else
            {
                return null;
            }
        } else
        {
            Queue<TreeNode> queue = new LinkedList<TreeNode>();
            queue.offer(treeNode);
            while (queue.size() > 0)
            {
                TreeNode node = queue.poll();
                if (node.id == id)
                {
                    return node;
                }

                if (node.isLeaf() == false)
                {
                    for (int i = 0; i < node.children.size(); i++)
                    {
                        queue.offer(node.children.get(i));
                    }
                }
            }

            return null;
        }
    }

    /**
     * 将节点插入为另一个节点的孩子
     * 
     * @param childNode
     * @param toBeAppended
     * @return
     */
    public static boolean appendAsChild(TreeNode childNode,
            TreeNode toBeAppended)
    {
        if (childNode == null || toBeAppended == null)
        {
            return false;
        } else
        {
            if (toBeAppended.isLeaf())
            {
                ArrayList<TreeNode> children = new ArrayList<TreeNode>();
                children.add(childNode);
                toBeAppended.children = children;
            } else
            {
                toBeAppended.children.add(childNode);
            }

            return true;
        }
    }

    /**
     * 将节点插入为另一个节点的兄弟
     * 
     * @param sublingNode
     * @param toBeAppended
     * @return
     */
    public static boolean appendAsSubling(TreeNode sublingNode,
            TreeNode toBeAppended)
    {
        if (sublingNode == null || toBeAppended == null)
        {
            return false;
        } else
        {
            // 单根树，无法对根节点添加兄弟
            if (toBeAppended.isRoot() == true)
            {
                return false;
            } else
            {
                toBeAppended.parent.children.add(sublingNode);
                return true;
            }
        }
    }
}

3.TreeHelper 提供了一段简单的代码来执行创建、查找等操作

package com.eyecm.tree;

/**
 * 辅助工具类
 * 
 */
public class TreeHelper
{
    int id;

    public int getId()
    {
        return id;
    }

    public void setId(int id)
    {
        this.id = id;
    }

    public static void main(String[] args)
    {
        NodeData root = new NodeData("root", "this is root");

        NodeData n1_1 = new NodeData("n1_1", "level 1");
        NodeData n1_2 = new NodeData("n1_2", "level 1");

        NodeData n2_1 = new NodeData("n2_1", "level 2,n1_1 child");
        NodeData n2_2 = new NodeData("n2_2", "level 2,n1_1 child");
        NodeData n2_3 = new NodeData("n2_3", "level 2,n1_2 child");
        NodeData n2_4 = new NodeData("n2_4", "level 2,n1_2 child");

        NodeData n3_1 = new NodeData("n3_1", "level 3,n2_2 child");

        TreeNode rootNode = new TreeNode(0, null, null, root);

        TreeNode n1_1_node = new TreeNode(1, null, null, n1_1);
        TreeNode n1_2_node = new TreeNode(2, null, null, n1_2);
        TreeNode.appendAsChild(n1_1_node, rootNode);
        TreeNode.appendAsChild(n1_2_node, rootNode);

        TreeNode n2_1_node = new TreeNode(4, null, null, n2_1);
        TreeNode n2_2_node = new TreeNode(5, null, null, n2_2);
        TreeNode.appendAsChild(n2_1_node, n1_1_node);
        TreeNode.appendAsChild(n2_2_node, n1_1_node);

        TreeNode n2_3_node = new TreeNode(6, null, null, n2_3);
        TreeNode n2_4_node = new TreeNode(7, null, null, n2_4);
        TreeNode.appendAsChild(n2_3_node, n1_2_node);
        TreeNode.appendAsChild(n2_4_node, n1_2_node);

        TreeNode n3_1_node = new TreeNode(13, null, null, n3_1);
        TreeNode.appendAsChild(n3_1_node, n2_2_node);

        TreeNode.levelTraversal(TreeNode.search(5, rootNode));
    }
}