N叉树节点绘制

一、接地坐标计算思路

由于在绘制N叉树的时候要每一个节点不能重叠，因此不能从顶节点开始绘制，只能先绘制叶子节点，在根据叶子节点的坐标来求得父节点的位置；

1、绘制一个节点：在绘制一个节点的时候先遍历绘制所有的子节点，再通过计算求得该节点坐标并进行绘制；

2、在绘制叶子节点时要注意，由于可能各个叶子节点的深度不同，因此每一个叶子节点在深度方向上的值是不能重叠的（即X不能相同），因此在画每一个叶子节点的时候要记录该叶子节点的X值，后面的叶子节点必须在这个叶子节点的X的基础上加上间隔；这样叶子节点X就不会重复，最后每一个节点就不会重复；

3、各个节点的Y值可以通过间隔与节点升读求得；

 

 

下面代码知识求得节点坐标方法；

N叉树节点定义

 public class NXNode
    {
        public int X;
        public int Y;
        public List<NXNode> Children = new List<NXNode>();

        int _depth = -1;
        public int Depth
        {
            get
            {
                return _depth;
            }
        }
        public int ID { get; private set; }

        NXNode _parentNode = null;
        public NXNode ParentNode
        {
            get
            {
                return _parentNode;
            }
        }
        /// <summary>
        /// 构件一个N叉树的节点
        /// </summary>
        /// <param name="id"></param>
        public NXNode(int id)
        {
            this.ID = id;
        }

        /// <summary>
        /// 添加一个节点
        /// </summary>
        /// <param name="node"></param>
        public void AddChildren(NXNode node)
        {
            if (node != null)
            {
                Children.Add(node);
                node._parentNode = this;
                node._depth = this.Depth + 1;
                UpdataChildrenDeth(node);
            }
        }
        /// <summary>
        /// 移除一个节点
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public bool RemoveChildren(NXNode node)
        {
            if (node != null)
            {
                node._parentNode = null;
                node._depth = -1;
                UpdataChildrenDeth(node);
                return Children.Remove(node);
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 在添加和或者移除一个节点时候更新该节点子节点的深度值
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        bool UpdataChildrenDeth(NXNode node)
        {
            try
            {
                if (node.Children.Count > 0)
                {
                    foreach (NXNode item in node.Children)
                    {
                        item._depth = node.Depth + 1;
                        UpdataChildrenDeth(item);
                    }
                }
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }
    }

下面是N叉树代码

   public class NXNodeTree
    {
        /// <summary>
        /// 节点间的宽度
        /// </summary>
        public static int NodeWSpacing = 10;
        /// <summary>
        /// 上下级节点的高度
        /// </summary>
        public static int NodeHSpacing = 10;
        /// <summary>
        /// Root 节点是虚拟的节点，在绘画的是时候不应该画出来
        /// </summary>
        public NXNode Root
        {
            get;
            private set;
        }
        public NXNodeTree(int maxNodeId)
        {
            NXNode rootNode = new NXNode(maxNodeId);
            this.Root = rootNode;
        }

        /// <summary>
        /// 用所给的PMapNode创建一棵NX树,这里的list的元素应该不能太多,要求nodeList进行排序
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        static public NXNodeTree CreatNXNodeTree(List<PMapNode> nodeList)
        {
            try
            {
                if (nodeList != null && nodeList.Count > 0)
                {
                    Dictionary<int, NXNode> dicNXNodes = new Dictionary<int, NXNode>();
                    int nodeParentID = nodeList[0].ParentID;
                    NXNodeTree nXNodeTree = new NXNodeTree(nodeParentID);
                    dicNXNodes.Add(nodeParentID, nXNodeTree.Root);

                    foreach (PMapNode item in nodeList)
                    {
                        NXNode node = new NXNode(item.ID);
                        if (dicNXNodes.ContainsKey(item.ParentID))
                        {
                            NXNode parentNode = dicNXNodes[item.ParentID];
                            parentNode.AddChildren(node);
                            dicNXNodes.Add(item.ID, node);
                        }
                        else
                        {

                        }
                    }
                    dicNXNodes.Clear();
                    return nXNodeTree;
                }
            }
            catch (Exception ex)
            {
                //TODO:记录错误
            }
            return null;
        }
        /// <summary>
        /// 计算树节点的坐标
        /// </summary>
        /// <param name="nXNodeTree"></param>
        public static void IniNXNodeTreeXY(NXNodeTree nXNodeTree)
        {
            if (nXNodeTree != null)
            {
                NXNode rootNode = nXNodeTree.Root;
                foreach (NXNode item in rootNode.Children)
                {
                    CalculateNXNodeXY(item);
                }
            }
        }
        /// <summary>
        /// 节点坐标的最小的X值
        /// </summary>
        static int drawMinX = 0;
        /// <summary>
        /// 如果需要绘制节点的时候对节点进行坐标计算
        /// </summary>
        /// <param name="node"></param>
        static void CalculateNXNodeXY(NXNode node)
        {
            if (node.Children.Count > 0)
            {
                int maxX = 0;
                foreach (NXNode childrenNode in node.Children)
                {
                    CalculateNXNodeXY(childrenNode);
                    maxX = childrenNode.X;
                }
                int minX = node.Children[0].X;
                node.X = (minX + maxX + 1) / 2;
                node.Y = node.Depth * NodeHSpacing;
            }
            else
            {
                drawMinX += NodeWSpacing;
                node.X = drawMinX;
                node.Y = node.Depth * NodeHSpacing;
            }
        }

    }

</pre><pre name="code" class="csharp">上下级关系定义类

</pre><pre name="code" class="csharp"> public class PMapNode
    {
        public int X;
        public int Y;
        public int ID { get; private set; }
        public PMapNode(int id, int parentID)
        {
            ID = id;
            ParentID = parentID;
        }
        public string Name { get; set; }
        public int ParentID { get; private set; }
        public int Generation { get; private set; }
    }