binomial-calculator/BinaryNode.java at master · lillyfwang/binomial-calculator · 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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
/**
 * Implementation of a BinaryNode used in the expression tree. Contains data and left and right BinaryNode
 * children. This also has some basic functions of a tree, including printing out the tree, evaluating the
 * tree, and creating an infix notation.
 */
class BinaryNode
{
    private String data;            // The data in the node
    private BinaryNode left;         // Left child
    private BinaryNode right;        // Right child
    static String output;
    static String infix;

    /**
     * Default contructor for BinaryNode
     */
    BinaryNode()
    {
        data = "";
        left =  null;
        right = null;
    }

    /**
     * Constructor for BinaryNode
     */
    BinaryNode(String theElement ,BinaryNode lt, BinaryNode rt )
    {
        data = theElement;
        left = lt;
        right = rt;
    }

    /**
     * A mutator method for the left child.
     */
    public void setLeftChild(BinaryNode lt)
    {
        left = lt;
    }

    /**
     * A mutator method for the right child
     */
    public void setRightChild(BinaryNode rt)
    {
        right = rt;
    }

    /**
     * A mutator method for the data
     */
    public void setData(String theElement)
    {
        data = theElement;
    }

    /**
     * An accessor method for the data
     */
    public String getData()
    {
        return data;
    }

    /**
     * Sets the string that stores the tree graphically.
     */
    public void resetOutput()
    {
        output = "";
    }

    /**
     * Creates a string that represents the tree graphically
     */
    public static String printTree(BinaryNode t , int indent)
    {
        if( t != null )
        {
            printTree( t.right, indent + 3 );
            for(int i=0;i<indent;i++)
                output += ("   ");
            output+=t.data+"\n";
            printTree( t.left , indent + 3 );
        }
        return output;
    }

    /**
     * Traverses the tree and evaluates the expression tree.
     */
    public double evaluate(BinaryNode node){
        if(node.data == "")
            return 0;
        else
        {
            char operator;
            switch (node.data.charAt(0))
            {
                case '+':
                return (evaluate(node.right) + evaluate(node.left));
                case '-':
                return (evaluate(node.right) - evaluate(node.left));
                case '*':
                return (evaluate(node.right) * evaluate(node.left));
                case '/':
                return (evaluate(node.right) / evaluate(node.left));
                case '^':
                return (Math.pow(evaluate(node.right), evaluate(node.left)));
                default:
                return Integer.parseInt(node.data);
            }
        }
    }

    /**
     * Creates an infix expression by traversing the expression tree.
     */
    public String infix(BinaryNode node)
    {
        infix = "";
        if(node.data == "")
            return "";
        else
        {
            switch (node.data.charAt(0))
            {
                case '+':
                return ("("+infix(node.right) +"+"+ infix(node.left)+")");
                case '-':
                return ("("+infix(node.right) +"-"+ infix(node.left)+")");
                case '*':
                return ("("+infix(node.right) +"*"+ infix(node.left)+")");
                case '/':
                return ("("+infix(node.right) +"/"+ infix(node.left)+")");
                case '^':
                return ("("+infix(node.right) +"^"+ infix(node.left)+")");
                default:
                return node.data;
            }
        }
    }
}