fix
Hentua
2023-06-06 0c27432b33d4fdbf7a7fdccb678a5679efe65d84
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
package cc.mrbird.febs.common.tree;
 
import cn.hutool.core.collection.CollUtil;
import lombok.extern.slf4j.Slf4j;
 
import java.util.ArrayDeque;
import java.util.List;
 
/**
 *
 *
 * @author wzy
 * @date 2023-04-18
 **/
@Slf4j
public class MatrixTree {
 
    private static final MatrixTree MATRIX_TREE = new MatrixTree();
    public static MatrixTree getInstance() {
        return MATRIX_TREE;
    }
 
    private int childNodeCnt = 3;
 
    // 节点数量
    private int count = 0;
    private MemberNode root;
 
    private MatrixTree() {
        count = 1;
    }
 
    /**
     * @param node 待添加的节点
     * @return 返回父节点
     */
    public MemberNode addNode(MemberNode node) {
        if (root == null) {
            root = node;
            return null;
        }
 
        MemberNode childTreeRoot = getNode(node.getRefererId());
 
        MemberNode parentNode = findNotWholeNode(childTreeRoot == null ? root : childTreeRoot);
        parentNode.addNode(node);
        return parentNode;
    }
 
    public MemberNode addNode(MemberNode node, Long parentNodeId) {
        if (parentNodeId == null) {
            root = node;
            return null;
        }
 
        MemberNode parentNode = getNode(parentNodeId);
        parentNode.addNode(node);
        return parentNode;
    }
 
    /**
     * 层级遍历,查到子节点未满3个的节点
     * @return
     */
    public MemberNode findNotWholeNode(MemberNode root) {
        ArrayDeque<MemberNode> deque = new ArrayDeque<>();
        deque.add(root);
 
        MemberNode result = null;
        while(!deque.isEmpty()) {
            int num = deque.size();
 
            for (int i = 0; i < num; i++) {
                MemberNode memberNode = deque.removeFirst();
                if (memberNode.CHILD.size() < childNodeCnt) {
                    result = memberNode;
                    break;
                }
 
                for (MemberNode node : memberNode.CHILD) {
                    deque.addLast(node);
                }
            }
 
            if (result != null) {
                break;
            }
        }
 
        return result;
    }
 
    public MemberNode findNotWholeNode() {
        return findNotWholeNode(root);
    }
 
    /**
     * 查找整个树下对应节点
     * @param param memberId/address/inviteId
     * @return
     */
    public MemberNode getNode(Object param) {
        if (root == null) {
            return null;
        }
 
        if (root.getMemberId().equals(param) || root.getPhone().equals(param) || root.getInviteId().equals(param)) {
            return root;
        }
 
        return getNode(root.CHILD, param);
    }
 
    /**
     * 查找某节点下的对应节点
     *
     * @param nodeList 某节点
     * @param param memberId/address/inviteId
     * @return
     */
    public MemberNode getNode(List<MemberNode> nodeList, Object param) {
        if (CollUtil.isEmpty(nodeList)) {
            return null;
        }
 
        for (MemberNode node : nodeList) {
            if (node.getMemberId().equals(param) || node.getPhone().equals(param) || node.getInviteId().equals(param)) {
                return node;
            }
 
            MemberNode childNode = getNode(node.CHILD, param);
            if (childNode != null) {
                return childNode;
            }
        }
 
        return null;
    }
}