Question

所以我正在构建一个小游戏，其中我想要一个包含所有可能移动的搜索树。但是，我在实现搜索树时遇到了一些困难。我已经设法构建了一个可以计算移动的函数但是我不确定如何构建树，它应该是递归的。每个节点都应该有一个包含所有可能移动的列表。

public class Tree {
private Node root;
private int level;

public Tree(int level, Board board) {
    this.level = level;
    root = new Node(board);
}


public void add(Board board) {
    int newLevel = board.numberPlacedDiscs();
    if(newLevel>level){
        //Add this at a new level.
        Node newNode =new Node(board);
        newNode.setParent(root);
        root = newNode;

    }else{
        //add at this level.
        root.addChild(new Node(board));
    }
}

}

public class Tree {
    private Node root;
    private int level;

public Tree(int level, Board board) {
    this.level = level;
    root = new Node(board);
}


public void add(Board board) {
    int newLevel = board.numberPlacedDiscs();
    if(newLevel>level){
        //Add this at a new level.
        Node newNode =new Node(board);
        newNode.setParent(root);
        root = newNode;

    }else{
        //add at this level.
        root.addChild(new Node(board));
    }
}

}

如您所见，我不知道如何添加新节点。我如何知道何时在树中的某个级别并添加更多节点？每次将新光盘添加到电路板时，它应该降低一级。

Answer 1

这是Java中的通用树

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TreeTest {

    public static void main(String[] args) {

        Tree tree = new Tree("root");
        tree.root.addChild(new Node("child 1"));
        tree.root.addChild(new Node("child 2"));

        tree.root.getChild("child 1").addChild("child 1-1");
        tree.root.getChild("child 1").addChild("child 1-2");

        /*
        root 
        -- child 1
        ---- child 1-1
        ---- child 1-2
        -- child 2
         */
    }

    private static class Tree {
        private Node root;

        Tree(String rootData) {
            root = new Node();
            root.data = rootData;
            root.children = new ArrayList<>();
        }

        public List<Node> getPathToNode(Node node) {
            Node currentNode = node;
            List<Node> reversePath = new ArrayList<>();
            reversePath.add(node);
            while (!(this.root.equals(currentNode))) {
                currentNode = currentNode.getParentNode();
                reversePath.add(currentNode);
            }
            Collections.reverse(reversePath);
            return reversePath;
        }

    }

    static class Node {
        String data;
        Node parent;
        List<Node> children;

        Node() {
            data = null;
            children = null;
            parent = null;
        }

        Node(String name) {
            this.data = name;
            this.children = new ArrayList<>();
        }

        void addChild(String name) {
            this.addChild(new Node(name));
        }

        void addChild(Node child) {
            this.children.add(child);
        }

        void removeChild(Node child) {
            this.children.remove(child);
        }

        public void removeChild(String name) {
            this.removeChild(this.getChild(name));
        }

        public Node getChild(int childIndex) {
            return this.children.get(childIndex);
        }

        Node getChild(String childName) {
            for (Node child : this.children) {
                if (child.data.equals(childName)) {
                    return child;
                }
            }
            return null;
        }

        Node getParentNode() {
            return this.parent;
        }
    }
}

blog post关于java中的通用树数据结构

希望有所帮助

Answer 2

您可以使用此方法将Node插入树中：

private void insertNode(Node root, Node oldNode, Node newNode) {
        if(root == null) {
           return;
        }

        if(root == oldNode) {
            oldNode.addChild(newNode);
            return;
        }

        for(Node child : root.getChildren()) {
            insertNode(child, oldNode, newNode);
        }
    }

所以这个方法有三个参数：

root - 这是树的根节点。
oldNode - 您要插入newNode。
newNode - 这是您要添加到oldNode的子节点的节点。

节点如果您传递树中不存在的Node，则不会抛出任何错误。但是如果你愿意，你可以修改它。

用Java构建搜索树

2 个答案: