Animal-Guessing-Game/BinaryNode.java at main · adarsh249/Animal-Guessing-Game · GitHub

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
package TreePackage;

class BinaryNode<T>
{
    private T data;
    private BinaryNode<T> leftChild;
    private BinaryNode<T> rightChild;

    public BinaryNode()
    {
        this(null);
    }

    public BinaryNode(T dataPortion)
    {
        this(dataPortion, null, null);
    }

    public BinaryNode(T dataPortion, BinaryNode<T> newLeftChild, BinaryNode<T> newRightChild)
    {
        data = dataPortion;
        leftChild = newLeftChild;
        rightChild = newRightChild;
    }

    public T getData()
    {
        return data;
    }

    public void setData(T newData)
    {
        data = newData;
    }

    public BinaryNode<T> getLeftChild()
    {
        return leftChild;
    }

    public void setLeftChild(BinaryNode<T> newLeftChild)
    {
        leftChild = newLeftChild;
    }

    public boolean hasLeftChild()
    {
        return leftChild != null;
    }

    public BinaryNode<T> getRightChild()
    {
        return rightChild;
    }

    public void setRightChild(BinaryNode<T> newRightChild)
    {
        rightChild = newRightChild;
    }

    public boolean hasRightChild()
    {
        return rightChild != null;
    }

    public boolean isLeaf()
    {
        return (leftChild == null) && (rightChild == null);
    }

    /** counts the nodes in the subtree rooted at this node
     * @return The number of nodes in the subtree rooted at this node
     */
    public int getNumberOfNodes()
    {
        int leftNumber = 0;
        int rightNumber = 0;

        if (leftChild != null)
        {
            leftNumber = leftChild.getNumberOfNodes();
        }

        if (rightChild != null)
        {
            rightNumber = rightChild.getNumberOfNodes();
        }
        return 1 + leftNumber + rightNumber;
    }

    /** Computes the height of the subtree rooted at this node
     * @return The height of the subtree rooted at this node
     */
    public int getHeight()
    {
        return getHeight(this);
    }

    private int getHeight(BinaryNode<T> node)
    {
        int height = 0;
        if(node != null)
        {
            height = 1 + Math.max(getHeight(node.getLeftChild()), getHeight(node.getRightChild()));
        }
        return height;
    }

    /** Copies the subtree rooted at this node
     * @return The root of a copy of the subtree rooted at this node.
     */
    public BinaryNode<T> copy()
    {
        BinaryNode<T> newRoot = new BinaryNode<>(data);
        if(leftChild != null)
        {
            newRoot.setLeftChild(leftChild.copy());
        }
        if(rightChild != null)
        {
            newRoot.setRightChild(rightChild.copy());
        }
        return newRoot;
    }
}