C＃树种群

Question

我需要创建一个像使用字符串字母的树。 例如：BAT树看起来像这样

                       #
              /        |      \
              B        A       T
             / \      / \     / \
            A   T    B   T   B   A
            |   |    |   |   |   |
            T   A    T   B   A   B

我尝试使用递归..但总是显示堆栈溢出。 任何人都可以建议一个有效的算法。逻辑应该适用于任何字母。 我没有在这里添加我的代码，因为它完全错误。我是使用数据结构进行编程的新手。

以下是我写的代码：

                   using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Tree_recursion
{
    class Program
    {
        static void Main(string[] args)
        {
            String str;
            Console.WriteLine("Word : ");
            str = Console.ReadLine();
            str = str + "*";
            int len = str.Length;
            int i=0;
            Char[] letters = new char[len];
            letters = str.ToCharArray();
            Node root = new Node('#');
            Node ret_node=new Node();
            for (int j = 0; j < len;j++ )
            {
                i = j;
                ret_node = root.Addnode(letters[i++]);
            }                                               
        }
    }
    class Node
    {
        public char c;
        public List<Node> Child = new List<Node>();
        public Node()
        {
        }
        public Node(char ch)
        {
            Node n=new Node();
            n.c=ch;
        }
        public Node Addnode(char ch)
        {
            if (ch == '*')
            {
                return null;
            }
            else
            {
                Node n1 = Addnode(ch++);
                this.Child.Add(n1);
                return n1;
            }
        }

    }
}

Answer 1

这适合我。

首先定义树结构：

public class Tree<T>
{
    public T Value { get; private set; }
    public IEnumerable<Tree<T>> Children { get; private set; }

    public Tree(T value, IEnumerable<Tree<T>> children)
    {
        this.Value = value;
        this.Children = new List<Tree<T>>(children);
    }

    public string Dump()
    {
        return this.Dump(0);
    }

    protected string Dump(int level)
    {
        var query =
            (new [] { "".PadLeft(level, '-') + this.Value.ToString() })
            .Concat(this.Children.Select(x => x.Dump(level + 1)));

        return String.Join(System.Environment.NewLine, query);
    }
}

您的节点结构使事情变得更加困难。

然后你可以像这样构建一棵树：

var text = "ABC";

Func<IEnumerable<char>, IEnumerable<Tree<char>>> build = null;
build = xs =>
    from x in xs
    select new Tree<char>(x, build(xs.Except(new [] { x })));

var tree = new Tree<char>('#', build(text));

在此树上运行Dump的结果是：

#
-A
--B
---C
--C
---B
-B
--A
---C
--C
---A
-C
--A
---B
--B
---A