主页 / 问题 / 791618
Accepted
Иван Гладуш
Asked:2020-02-28 22:50:20 +0000 UTC2020-02-28 22:50:20 +0000 UTC

树数据结构的构建器？

  • 772

有必要为树状数据结构实现模式构建器。我尝试过的一切都表明，这很难做到，而且非常不方便，而且在一些新的之后更容易做到。如果有人解决了类似的问题并展示了这样一个构建器的例子，我会非常高兴。

java

2 个回答

  1. Best Answer

    假设我们要构建一棵树。我们有一个节点

    public class Node
{
    public int Value { get; set;}
    public Node Left { get; set;}
    public Node Right { get; set;}  
}

    下面是一个流利的构建器的例子。即调用可以组合成链来构建树

    public class TreeBuilder 
{
    private InnerNode _root;
    private InnerNode _currentNode;

    private TreeBuilder(int value)
    {
        _root = new InnerNode() { Value = value };
        _currentNode = _root;
    }

    public static TreeBuilder Create(int value)
    {
        return new TreeBuilder(value);
    }

    public TreeBuilder AddLeft(int value)
    {
        _currentNode.Left = new InnerNode() { Value = value, Parent = _currentNode };
        return Left();
    }

    public TreeBuilder AddRight(int value)
    {
        _currentNode.Right = new InnerNode() { Value = value, Parent = _currentNode };
        return Right();
    }

    public TreeBuilder Left()
    {
        _currentNode = _currentNode.Left;
        return this;
    }

    public TreeBuilder Right()
    {
        _currentNode = _currentNode.Right;
        return this;
    }

    public TreeBuilder Root()
    {
        _currentNode = _root;
        return this;
    }

    public TreeBuilder Parent()
    {
        _currentNode = _currentNode.Parent;
        return this;
    }

    public Node Build()
    {
        return Build(_root);
    }

    private Node Build (InnerNode node)
    {
        if (node == null) return null;
        return new Node() {Value = node.Value, Left =Build(node.Left), Right=Build(node.Right)};
    }

    private class InnerNode
    {
        public int Value { get; set; }
        public InnerNode Left { get; set; }
        public InnerNode Right { get; set; }
        public InnerNode Parent { get; set; }
    }
}

    在构建器内部，为了表示不完整的树，我使用了一个单独的类，因为这个类有一个到父级的链接，并且用它遍历节点更方便。从理论上讲，可以根据需要积累有关正在构建的对象的信息。

    好吧，实际上，使用：

    var root = TreeBuilder
            .Create(10)
                .AddLeft(5)
                    .Parent()
                .AddRight(15)
                    .AddLeft(10)
                    .Build();                       


//   10
//  /  \
//  5   15
//      /
//     10
    • 8

  2. 我会冒着引用来源的风险。结果发现了很多代码：

    private static class Team {
    public final List<Player> players;

    public Team(List<Player> players) {
        this.players = Collections.unmodifiableList(players);
    }

    public static TeamBuilder builder() {
        return new TeamBuilder();
    }

    static class TeamBuilder {
        private List<Player.PlayBuilder> playerBuilders = new ArrayList<>();

        public TeamBuilder add(Player.PlayBuilder builder) {
            playerBuilders.add(builder);
            return this;
        }

        public Team build() {
            List<Player> players = new ArrayList<>();
            for (Player.PlayBuilder playerBuilder : playerBuilders)
                players.add(playerBuilder.build());

            return new Team(players);
        }
    }

    static class Player {
        public final String name;

        Player(String name) {
            this.name = name;
        }

        public static PlayBuilder builder() {
            return new PlayBuilder();
        }

        static class PlayBuilder {
            private String name;

            public Player build() {
                return new Player(name);
            }

            public PlayBuilder setName(String name) {
                this.name = name;
                return this;
            }
        }
    }
}

    像这样使用：

    Team.builder()
    .add(Team.Player
             .builder()
             .setName("first player"))
    .add(Team.Player
             .builder()
             .setName("second player"))
    .add(Team.Player
             .builder()
             .setName("third player"))
    .build();

    主要思想是为每个对象创建自己的构建器，然后将其转移到另一个对象，依此类推。

    • 2

相关问题