如何从树叶层开始建树？

     在开发软件的过程中，遇到一个树形结构的问题，如下图：

      

     由于树形结构太大，只显示部分叶节点，并且报价是叶节点的数量和报价的成积。

 问题经分析很显然：变成了如下两个问题：

1从树的根节点开始建树就是一个简单的递归，但现在的问题是从树的叶节点开始如何建树，涉及到一个如何合并子节点的问题。

2如何根据叶节点的数量和报价计算各级父节点的报价？

1如何从树的叶节点开始如何建树？

 有一种思路，就是按照正常思路建好后，然后把没有子节点的删掉，很麻烦。

于是想着能不能通过叶节点的递归一层一层向上，最终完成树的创建。

最总实现代码如下：

 /// <summary>
    /// 返回需要的树
    /// </summary>
    /// <param name="listAllNodes">所有的节点信息</param>
    /// <param name="dicNode">键为父节点编号，值为父节点对应的子节点  ，初始为需要显示的叶节点</param>
    /// <returns></returns>
    public static List<TreeNode> GeTree(List<TreeNode> listAllNodes, Dictionary<int, List<TreeNode>> dicNode)
    {
        int rootNodeId = -1;//虚拟的根节点编号
        while (!dicNode.ContainsKey(rootNodeId)) //如果没有到根节点继续
        {
            dicNode = GetOneLevelNodes(listAllNodes, dicNode);
        }
        return dicNode[rootNodeId];
    }
    /// <summary>
    /// 返回某一层的所有节点，包含子节点
    /// </summary>
    /// <param name="listAllNodes">所有的节点信息</param>
    /// <param name="dicNode">键为父节点编号，值为父节点对应的子节点</param>
    /// <returns></returns>
    private static Dictionary<int, List<TreeNode>> GetOneLevelNodes(List<TreeNode> listAllNodes, Dictionary<int, List<TreeNode>> dicNode)
    {
        int rootNodeId = -1; //虚拟的根节点编号      
        List<int> ParentsIdList = new List<int>();
        ParentsIdList.AddRange(dicNode.Keys);//这次需要添加的节点编号
        Dictionary<int, List<TreeNode>> dicNode2 = new Dictionary<int, List<TreeNode>>();//键为父节点编号，值为父节点对应的子节点
        for (int i = listAllNodes.Count - 1; i >= 0; i--)
        {
            TreeNode item = listAllNodes[i];
            if (ParentsIdList.Contains(item.ID))
            {               
                int parentId = rootNodeId;//默认为顶级节点
                if (item.ParentID.HasValue)//如果存在父节点
                {
                    parentId = item.ParentID.Value;
                }
                List<TreeNode> children = dicNode[item.ID];//获取此节点对应的父节点
                item.children = children;//添加子节点
                AddOneNode(parentId, dicNode2, item);//添加节点到字典中
                listAllNodes.RemoveAt(i);//移除已经处理的节点
            }
        }
        return dicNode2;
    }
    /// <summary>
    /// 合并具有相同父节点的兄弟节点
    /// </summary>
    /// <param name="parentId">需要处理的节点的父节点</param>
    /// <param name="dicNode">此层对应的节点字典</param>
    /// <param name="node">需要处理的节点</param>
    private static void AddOneNode(int parentId, Dictionary<int, List<TreeNode>> dicNode, TreeNode node)
    {
        if (dicNode.ContainsKey(parentId))//如果有
        {
            dicNode[parentId].Add(node);//如果具有相同的父节点，则添加到相应的兄弟节点列表中
        }
        else//如果没有
        {
            List<TreeNode> listChild = new List<TreeNode>();
            listChild.Add(node);//兄弟节点列表
            dicNode.Add(parentId, listChild);
        }
    }   

2如何根据叶节点的数量和报价计算各级父节点的报价？

     由于每一个节点的报价都是通过它的子节点的报价计算出来的，似乎在树建成后，还需要遍历一次计算报价？如何写代码？似乎还真不好处理？

     想不到最总却是通过属性解决的。

核心代码如下：

  

 private double m_Price = 0;//默认为0，
    public double Price
    {
        get
        {
            if (m_Price == 0)//如果是默认值，则调用方法计算
            {
                m_Price = GetPrice(); 
            }
            return m_Price;
        }
        set { m_Price = value; }
    }
    /// <summary>
    /// 通过子节点计算此节点的报价
    /// </summary>
    /// <returns></returns>
    private double GetPrice()
    {
        if (m_Price > 0)//已经计算过，直接返回
        {
            return m_Price;
        }

        double PriceTemp = 0;
        if (children != null && children.Count > 0)
        {
            foreach (TreeNode node in children)// 通过子节点计算此节点的报价
            {
                if (node.Count.HasValue)
                {
                    PriceTemp += node.Count.Value * node.Price;
                }
                else
                {
                    PriceTemp += node.Price;
                }
            }
        }      
        return PriceTemp;
    }

  完整代码：

public class TreeNode
{
    private int m_ID;
    public int ID
    {
        get { return ID; }
        set { ID = value; }
    }
    private int? m_ParentID;
    public int? ParentID
    {
        get { return m_ParentID; }
        set { m_ParentID = value; }
    }
    private int? m_Count;
    public int? Count
    {
        get { return m_Count; }
        set { m_Count = value; }
    }
    private string m_PL_Code;
    public string PL_Code
    {
        get { return m_PL_Code; }
        set { m_PL_Code = value; }
    }  
    private string m_Name;
    public string Name
    {
        get { return m_Name; }
        set { m_Name = value; }
    }
    private double m_Price = 0;//默认为0，
    public double Price
    {
        get
        {
            if (m_Price == 0)//如果是默认值，则调用方法计算
            {
                m_Price = GetPrice(); 
            }
            return m_Price;
        }
        set { m_Price = value; }
    }
    /// <summary>
    /// 通过子节点计算此节点的报价
    /// </summary>
    /// <returns></returns>
    private double GetPrice()
    {
        if (m_Price > 0)//已经计算过，直接返回
        {
            return m_Price;
        }

        double PriceTemp = 0;
        if (children != null && children.Count > 0)
        {
            foreach (TreeNode node in children)// 通过子节点计算此节点的报价
            {
                if (node.Count.HasValue)
                {
                    PriceTemp += node.Count.Value * node.Price;
                }
                else
                {
                    PriceTemp += node.Price;
                }
            }
        }      
        return PriceTemp;
    }
    private List<TreeNode> m_children;
    public List<TreeNode> children
    {
        get { return m_children; }
        set { m_children = value; }
    }
    /// <summary>
    /// 返回需要的树
    /// </summary>
    /// <param name="listAllNodes">所有的节点信息</param>
    /// <param name="dicNode">键为父节点编号，值为父节点对应的子节点  ，初始为需要显示的叶节点</param>
    /// <returns></returns>
    public static List<TreeNode> GeTree(List<TreeNode> listAllNodes, Dictionary<int, List<TreeNode>> dicNode)
    {
        int rootNodeId = -1;//虚拟的根节点编号
        while (!dicNode.ContainsKey(rootNodeId)) //如果没有到根节点继续
        {
            dicNode = GetOneLevelNodes(listAllNodes, dicNode);
        }
        return dicNode[rootNodeId];
    }
    /// <summary>
    /// 返回某一层的所有节点，包含子节点
    /// </summary>
    /// <param name="listAllNodes">所有的节点信息</param>
    /// <param name="dicNode">键为父节点编号，值为父节点对应的子节点</param>
    /// <returns></returns>
    private static Dictionary<int, List<TreeNode>> GetOneLevelNodes(List<TreeNode> listAllNodes, Dictionary<int, List<TreeNode>> dicNode)
    {
        int rootNodeId = -1; //虚拟的根节点编号      
        List<int> ParentsIdList = new List<int>();
        ParentsIdList.AddRange(dicNode.Keys);//这次需要添加的节点编号
        Dictionary<int, List<TreeNode>> dicNode2 = new Dictionary<int, List<TreeNode>>();//键为父节点编号，值为父节点对应的子节点
        for (int i = listAllNodes.Count - 1; i >= 0; i--)
        {
            TreeNode item = listAllNodes[i];
            if (ParentsIdList.Contains(item.ID))
            {               
                int parentId = rootNodeId;//默认为顶级节点
                if (item.ParentID.HasValue)//如果存在父节点
                {
                    parentId = item.ParentID.Value;
                }
                List<TreeNode> children = dicNode[item.ID];//获取此节点对应的子节点
                item.children = children;//添加子节点
                AddOneNode(parentId, dicNode2, item);//添加节点到字典中
                listAllNodes.RemoveAt(i);//移除已经处理的节点
            }
        }
        return dicNode2;
    }
    /// <summary>
    /// 合并具有相同父节点的兄弟节点
    /// </summary>
    /// <param name="parentId">需要处理的节点的父节点</param>
    /// <param name="dicNode">此层对应的节点字典</param>
    /// <param name="node">需要处理的节点</param>
    private static void AddOneNode(int parentId, Dictionary<int, List<TreeNode>> dicNode, TreeNode node)
    {
        if (dicNode.ContainsKey(parentId))//如果有
        {
            dicNode[parentId].Add(node);//如果具有相同的父节点，则添加到相应的兄弟节点列表中
        }
        else//如果没有
        {
            List<TreeNode> listChild = new List<TreeNode>();
            listChild.Add(node);//兄弟节点列表
            dicNode.Add(parentId, listChild);
        }
    }   
}