C# 非递归列表转树形结构的实现

说道树结构，很容易想到以下的数据结构

    class Node
    {
        public string ID { get; set; }
        public string ParentID { get; set; }
        public List<Node> Children { get; set; }
    }

一般的数据都是从数据库中读取，将数据转换为对应的实体主要有一下几种方式：
全部读取，直接转换为对应的树或者部分读取，每次点击节点的的时候再加载下级数据。

本文不讨论部分读取的情况，主要涉及的是全部读取，转为树的做法。

网上最常见的方式就是递归，思路是找出所有第一层节点，然后层层遍历，类似下面的代码

        public static List<Node> GetTree(List<Node> nodes)
        {
            var list = nodes.FindAll(a => a.ParentID == "0");
            foreach (var node in list)
            {
                GetTree(node, nodes);
            }
            return list;
        }


        public static void GetTree(Node paretnNode, List<Node> nodes)
        {
            foreach (var node in nodes)
            {
                if (node.ParentID == paretnNode.ID)
                {
                    GetTree(node, nodes);
                    paretnNode.Children.Add(node);
                }
            }
        }

写递归，总觉得好麻烦，而其需要两个方法，有没有非递归的形式？
由树的非递归遍历使用队列想到，可以用类似的方法实现，代码如下

        public static List<Node> GetTree(List<Node> list, Func<Node, bool> IsRoot)
        {
            var _list = new List<Node>(list);//复制 不修改原始数据
            for (int i = _list.Count() - 1; i > -1; i--)//不能使用foreach 删除或者添加元素。顺序遍历，删除元素之后，需要对当前索引执行--操作。逆序删除节点不需要特殊处理           
            {
                Node node = _list[i];
                if (!IsRoot(node))//顶级节点
                {
                    Node pNode = _list.FirstOrDefault(a => a.ID == node.ParentID);//找到父节点
                    if (pNode != null)
                    {
                        pNode.Children.Add(node);//添加节点
                    }
                    _list.RemoveAt(i);//无论是否找到 删除，剩下的全部为顶级节点
                }
            }
            return _list;
        }

主要思路就是每次遍历时，判断是否为顶级节点，如果不是，找到父节点，添加到父节点的子集中，删除该元素。
到遍历完成时，剩下的全部都是顶级元素，自然就是需要的树结构。

上面的Node类只是最基本的树状结构，实际使用当中，节点还有很多其他的属性，马上想到的时候通过继承Node类来实现通用。

    public class MyTreeNode : Node
    {
        public string Name { get; set; }
    }

            TreeNode.GetTree(new List<MyTreeNode>()
            {
                 new MyTreeNode { ID = "1", ParentID = "0", Name = "节点1" },
                 new MyTreeNode { ID = "2", ParentID = "0", Name = "节点2" },
                 new MyTreeNode { ID = "3", ParentID = "1", Name = "节点3" },
                 new MyTreeNode { ID = "4", ParentID = "1", Name = "节点4" },
                 new MyTreeNode { ID = "5", ParentID = "2", Name = "节点5" },
                 new MyTreeNode { ID = "6", ParentID = "1", Name = "节点6" },
                 new MyTreeNode { ID = "7", ParentID = "5", Name = "节点7" },
                 new MyTreeNode { ID = "8", ParentID = "7", Name = "节点8" },
                 new MyTreeNode { ID = "9", ParentID = "20", Name = "节点9" }
            }, a => a.ParentID == "0");

编译报错：错误 2 参数 1: 无法从“System.Collections.Generic.List<test.MyTreeNode>”转换为“System.Collections.Generic.List<test.Node>”

纳尼？MyTreeNode明明继承于Node，List<MyTreeNode>竟然不能转为List<Node>？
事实就是这么残酷，我们将上面的GetTree方法参数 list 从List<Node>改为IEnumerable<Node> ，编译就能通过了。
此处涉及到协变和逆变，具体不展开，请查阅相关资料。

由于基类的GetTree方法 返回的 是List<Node>，子类调用方法之后，需要再转换，最简单的就是在foreach中

            foreach (var item in _list)
            {
                Console.WriteLine(item.Name);//error
            }
            foreach (MyTreeNode item in _list)
            {
                Console.WriteLine(item.Name);
            }

在第一个foreah中，item的编译类型是Node，所以不能使用Name属性，在第二个foreach中，我们指定了遍历时的类型，代码等效于

           
            foreach (var item in _list)
            {
                MyTreeNode newitem = (MyTreeNode)item;
                Console.WriteLine(newitem.Name);
            }

大功告成。本文到此告一段落。

----------------------------------------苦逼的分割线--------------------------------------------

如果使用的是.net4.0及以上版本，就不需要再往下看了，可是苦逼的我用的是.net3.5，不能使用协变。
难道传给GetTree方法中的参数还需要再转型一遍？这样的代码，实在是缺乏美感。有木有其他的方法？

最近主要在学js，很多框架都有warp实现，马上想到通过给Node类外面包装一层

    public class Wrap
    {
        public string ID { get; set; }
        public string ParentID { get; set; }
        public List<Wrap> Children { get; set; }

        public Node Target { get; set; }

        public Wrap(Node node)
        {
            this.Target = node;
            this.ID = node.ID;
            this.ParentID = node.ParentID;
            this.Children = new List<Wrap>();
        }

        public static List<Wrap> GetTree(IEnumerable<Wrap> list, Func<Wrap, bool> IsRoot)
        {
            var _list = new List<Wrap>(list);
            for (int i = _list.Count() - 1; i > -1; i--)
            {
                Wrap node = _list[i];
                if (!IsRoot(node))
                {
                    Wrap pNode = _list.FirstOrDefault(a => a.ID == node.ParentID);
                    if (pNode != null)
                    {
                        pNode.Children.Add(node);
                    }
                    _list.RemoveAt(i);
                }
            }
            return _list;
        }
    }

用起来还是不爽，List<Warp>遍历解包得到Node，还要转型为实际类型，感觉更麻烦了！
将Node改为泛型T，试试看

    public class Wrap<T> where T : Node
    {
        public string ID { get; set; }
        public string ParentID { get; set; }
        public List<Wrap<T>> Children { get; set; }

        public T Target { get; set; }

        public Wrap(T node)
        {
            this.Target = node;
            this.ID = node.ID;
            this.ParentID = node.ParentID;
            this.Children = new List<Wrap>();
        }

        public static List<Wrap<T>> GetTree(IEnumerable<Wrap<T>> list, Func<Wrap<T>, bool> IsRoot)
        {
            var _list = new List<Wrap<T>>(list);
            for (int i = _list.Count() - 1; i > -1; i--)
            {
                Wrap<T> node = _list[i];
                if (!IsRoot(node))
                {
                    Wrap<T> pNode = _list.FirstOrDefault(a => a.ID == node.ParentID);
                    if (pNode != null)
                    {
                        pNode.Children.Add(node);
                    }
                    _list.RemoveAt(i);
                }
            }
            return _list;
        }
    }

可喜可贺，现在只需要遍历解包就能得到正确的列表了，能不能更近一步？
可以：这个时候，该重载运算符这个大杀器出场了

        public static List<Wrap<T>> GetTree(IEnumerable<T> list, Func<Wrap<T>, bool> IsRoot)
        {
            var _list = new List<Wrap<T>>(list.Count());//手动copy
            foreach (T t in list)
            {
                _list.Add(t);
            }
            for (int i = _list.Count() - 1; i > -1; i--)
            {
                Wrap<T> node = _list[i];
                if (!IsRoot(node))
                {
                    Wrap<T> pNode = _list.FirstOrDefault(a => a.ID == node.ParentID);
                    if (pNode != null)
                    {
                        pNode.Children.Add(node);
                    }
                    _list.RemoveAt(i);
                }
            }
            return _list;
        }

        public static implicit operator T(Wrap<T> warp)
        {
            return warp.Target;
        }

        public static implicit operator Wrap<T>(T t)
        {
            return new Wrap<T>(t);
        }

重载之后，使用起来和上面的那个版本基本一致。
仔细观察 Wrap的结构，可以发现和Node类的属性一摸一样，可以直接令Wrap继承于Node，代码职责是否清晰，就仁者见仁智者见智了。

其实这些都是扯淡，老老实实用上面的版本。。。。

--------------------------------最后的分割线------------------------------------

上面的代码，其中缺了一点，就是 Children中的排序，一般来说，树的每个节点都是有对应的顺序的。
（其实是因为倒序删除导致了顺序不对-_-，可以改为顺序删除）
补充如下：

                    …………
                    if (pNode != null)
                    {
                        pNode.Children.Add(node);//添加节点
                        if (NeedOrder)
                        {
                            pNode.Children = pNode.Children.OrderBy(a => a.Sequence).ToList();
                        }
                    }
                    …………

总结：本文主要涉及到的知识点：linq，递归，泛型，协变，类型转换，操作符重载
实质是用双重循环（不包括排序）来替代递归，具体效率嘛，呵呵 你懂的，在实际生产环境谨慎使用