public class BinTree<T extends Comparable<T>> { private BTNode<T> root; private BTNode<T> actual; private BTNode<T> father; private int calculate(char c, int left, int right) { switch (c) { case '+': return (left + right); case '-': return (left - right); case '*': return (left * right); case '/': return (left / right); default: return 0; } } private int count(BTNode<T> pNode, T x) { /* * Kasu nabariak: * Zuhaitza hutsa bada, 0 itzuli * Kasu orokorrak: * Zuhaitzaren erroa bilatzen ari garen elementua bada * 1 + ezkerreko zuhaitza + eskuineko zuhaitza itzuli. * Bestela, ezkerreko zuhaitza + eskuineko zuhaitza itzuli. */ if (pNode != null) { if (x.equals(pNode.content)) { return 1 + count(pNode.left, x) + count(pNode.right, x); } else { return count(pNode.left, x) + count(pNode.right, x); } } else { return 0; } } public int count(T x) { return count(root, x); } public int evaluate() { return this.evaluate(root); } private int evaluate (BTNode<T> pNode){ Character c; /* * pNode.content T mota generikokoa da. * Character bati esleitzeko, lehenik String-era * bihurtu behar dugu (objektu guztiak String batean * bihurtu daitezke), eta ondoren, charAt() metodoa * erabiliko dugu. */ c = ((String)pNode.content).charAt(0); if (Character.isDigit(c.charValue())) { return Integer.parseInt(c.toString()); } else { int left = evaluate(pNode.left); int right = evaluate(pNode.right); return calculate(c.charValue(), left, right); } } private boolean find(BTNode<T> pNode, T pValue) { T i; if (pNode != null) { i = pNode.content; /* * Generikoak erabiltzen ari garenez, ez dakigu * objektuak konparagarriak diren edo ez. * * Beraz, esan behar dugu T konparagarria * izan behar dela. * Horretarako klasea honela definituko dugu: * * public class BinTree<T extends Comparable<T>> { * */ if (i.compareTo(pValue) == 0) { return true; } else { return (find(pNode.left, pValue) || find (pNode.right, pValue)); } } return false; } public boolean find(T pValue) { return find(root, pValue); } public T getActual() { return actual.content; } public BTNode<T> getActualPointer() { return actual; } public BTNode<T> getRootPointer() { return root; } public void goBrother() { if (father.left == actual) { actual = father.right; } else { actual = father.left; } } public void goLeft() { father = actual; actual = actual.left; } public void goRight() { father = actual; actual = actual.right; } public void goRoot() { father = null; actual = root; } public void insertLeftChild(T t) { actual.left = new BTNode<T>(t); } public void insertRightChild(T t) { actual.right = new BTNode<T>(t); } public void insertRoot(T t) { root = new BTNode<T>(t); actual = root; } public boolean isEmpty() { return (root == null); } public boolean isExternal() { return (actual.left == null && actual.right == null); } public boolean isInternal() { return !this.isExternal(); } public boolean isRoot() { return (actual == root); } public void setActual(T element) { actual.content = element; } public int tamaina(BTNode<T> pNode) { /* * Kasu Nabariak: * Zuhaitza hutsa bada, 0 itzuli. * Kasu Orokorrak: * Erroa hutsa ez bada, * 1 + ezkerreko zuhaitza + eskuineko zuhaitza itzuli. */ if (pNode != null) { return 1 + tamaina(pNode.left) + tamaina(pNode.right); } else { return 0; } } public int altuera() { return altuera(root); } public int altuera(BTNode<T> pNode) { /* * Kasu Nabaria: * Hutsa bada, 0 itzuli. * Hostoa bada, 0 itzuli. * Kasu Orokorrak: * Ez bada hostoa, 1 + bere humeen altuera maximoa */ if (pNode != null && pNode.right != null && pNode.left != null) { int ezkerra = altuera(pNode.left); int eskuina = altuera(pNode.right); return (1 + ((eskuina >= ezkerra) ? eskuina : ezkerra)); } else { return 0; } }}