多叉树组合运算（未完待续）

package org.example.tree;

import java.util.List;

public class TreeNode {
    private List<TreeNode> childs;
    private String op;
    private boolean isLeaf;

    private String val;

    private TreeNode parent;

    public List<TreeNode> getChilds() {
        return childs;
    }

    public void setChilds(List<TreeNode> childs) {
        this.childs = childs;
    }

    public String getOp() {
        return op;
    }

    public void setOp(String op) {
        this.op = op;
    }

    public boolean isLeaf() {
        return isLeaf;
    }

    public void setLeaf(boolean leaf) {
        isLeaf = leaf;
    }

    public String getVal() {
        return val;
    }

    public void setVal(String val) {
        this.val = val;
    }

    public TreeNode(List<TreeNode> childs, String op) {
        this.childs = childs;
        this.op = op;
        this.isLeaf = false;
        for (TreeNode child : childs) {
            child.setParent(this);
        }
    }

    public TreeNode( String val) {
        this.isLeaf = true;
        this.val = val;
    }

    public TreeNode getParent() {
        return parent;
    }

    public void setParent(TreeNode parent) {
        this.parent = parent;
    }
}

package org.example.tree;

import cn.hutool.core.collection.CollectionUtil;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class TreeMain {

    public static void main(String[] args) {
        TreeNode leaf1 = new TreeNode("A");
        TreeNode leaf2 = new TreeNode("B");
        TreeNode leaf3 = new TreeNode("C");

        TreeNode leaf7 = new TreeNode("G");
        TreeNode leaf8 = new TreeNode("H");

        TreeNode leaf4 = new TreeNode("E");
        TreeNode leaf6 = new TreeNode("F");

        List<TreeNode> leaf5Child = new ArrayList<>();
        leaf5Child.add(leaf7);
        leaf5Child.add(leaf8);
        TreeNode leaf5 = new TreeNode(leaf5Child,"&&");

        List<TreeNode> node1Child = new ArrayList<>();
        node1Child.add(leaf1);
        node1Child.add(leaf2);

        List<TreeNode> node2Child = new ArrayList<>();
        node2Child.add(leaf3);
        node2Child.add(leaf5);
        node2Child.add(leaf4);
        node2Child.add(leaf6);

        TreeNode node1 = new TreeNode(node1Child,"||");
        TreeNode node2 = new TreeNode(node2Child,"||");
        List<TreeNode> rootChilds = new ArrayList<>();
        rootChilds.add(node1);
        rootChilds.add(node2);

        TreeNode nodeRoot = new TreeNode(rootChilds,"&&");
        System.out.println(nodeRoot);
        traversal(nodeRoot);
    }


    private static void traversal(TreeNode treeNode){
        if(treeNode.isLeaf()){
            System.out.println(treeNode.getVal());
        }else {
            List<TreeNode> childs = treeNode.getChilds();
            boolean canMergeAnd = canMergeAnd(treeNode);
            if(canMergeAnd){
                String newVal = treeNode.getChilds().stream().map(item -> item.getVal()).collect(Collectors.joining(""));
                treeNode.setVal(newVal);
                treeNode.setChilds(null);
                treeNode.setOp(null);
                treeNode.setLeaf(true);
                System.out.println("合并："+newVal);
                traversal(treeNode.getParent());
            }else if(canMergeAndOrOr(treeNode)){

            }else  {
                System.out.println(treeNode.hashCode()+" ->mergeAnd："+ canMergeAnd);
                for (TreeNode child : childs) {
                    traversal(child);
                }
            }
        }
    }

    /**
     * 是否可以进行 && 合并
     * @param treeNode
     * @return
     */
    private static boolean canMergeAnd(TreeNode treeNode){
        if(!treeNode.isLeaf() &&  "&&".equals(treeNode.getOp())){
            long count = treeNode.getChilds().stream().filter(item -> !item.isLeaf()).count();
            return count == 0;
        }
        return false;
    }
    private static boolean canMergeAndOrOr(TreeNode treeNode){
        if(!treeNode.isLeaf() &&  "&&".equals(treeNode.getOp())){
            List<TreeNode> childs = treeNode.getChilds();
            long count = childs.stream().filter(item -> !item.isLeaf() && "||".equals(item.getOp())).count();
            if(count == childs.size()){
                for (TreeNode child : childs) {
                    // 判断是否有非叶子
                    boolean isHasNode = child.getChilds().stream().filter(item -> !item.isLeaf()).findAny().isPresent();
                    return !isHasNode;
                }
            }
        }
        return false;
    }
}