Boafire patch 1

InClass/mar22/trie_node.java

@@ -0,0 +1,46 @@
+/*
+It should be noted that this is neither a complete java file nor all the solution to all of the questions for this recitation. It is the code for the problems that are for getting you used to Tries, but not the code that is a direct part of the Boggle assignment.
+
+Additionally several of the questions from the recitation were non-coding questions. Those are not included in this file.
+
+*/
+
+ private Node copyTrie(Node root){
+
+    if (root == null) return null;
+
+    Node copy = new Node(root.info.charAt(0),null);
+    copy.isWord = root.isWord;
+    copy.info = root.info;
+
+    // now copy children of root and then set all
+    // the copied children's parents pointers to 'copy'
+
+    for(Character c : root.children.keySet()){
+      Node child = root.children.get(c);
+      Node childCopy = copyTrie(child);
+
+      childCopy.parent = copy;
+      copy.children.put(c, childCopy);
+    }
+
+
+    return copy;
+  }
+
+  private int wordCount(Node root){
+
+    if (root == null) return 0;
+
+    int result = 0;
+    if(root.isWord)
+      result++;
+
+
+    for(Character c : root.children.keySet()){
+      result += wordCount(root.children.get(c));
+    }
+
+    return result;
+
+  }

Recitations/4/compsci201_Recitation7

@@ -0,0 +1,350 @@
+
+public class BST {
+
+  TreeNode root = null;
+
+  public class TreeNode {
+    public int myValue;
+    public TreeNode left; // holds smaller tree nodes
+    public TreeNode right; // holds larger tree nodes
+
+    public TreeNode(int val) { myValue = val; }
+  }
+
+  public void add(int newValue)
+  {
+    if(root == null)
+      root = new TreeNode(newValue);
+    else
+      add(newValue, root);
+  }
+  public void add(int newValue, TreeNode current) {
+    if (newValue < current.myValue) {
+      if (current.left == null) {
+        current.left = new TreeNode(newValue);
+      } else {
+        add(newValue, current.left);
+      }
+    } else {
+      // newValue >= myValue
+      if (current.right == null) {
+        current.right = new TreeNode(newValue);
+      } else {
+        add(newValue, current.right);
+      }
+    }
+  }
+
+  public String toString()
+  {
+    return toString(root, "");
+  }
+  public String toString(TreeNode current, String level) {
+    String leftString = "null";
+    String rightString = "null";
+
+    if (current.left != null)
+      leftString = toString(current.left, level+"   ");
+    if (current.right != null)
+      rightString = toString(current.right, level+"   ");
+
+    return current.myValue + "\n" + level +"L: " + leftString + "\n" + level + "R: " + rightString;
+  }
+
+  public int computeHeight()
+  {
+    return computeHeight(root);
+  }
+  private int computeHeight(TreeNode current) {
+    if(current == null)
+      return 0;
+    int lResult = computeHeight(current.left);
+    int rResult = computeHeight(current.right);
+    if(lResult > rResult) {
+      return lResult + 1;
+    } else {
+      return rResult + 1;
+    }
+  }
+
+  public int countNodes()
+  {
+    return countNodes(root);
+  }   
+  public int countNodes(TreeNode current)
+  {
+    if(current == null) {
+      return 0;
+    }
+    int lCount = countNodes(current.left);
+    int rCount = countNodes(current.right);
+
+    // your code here
+    return 1 + lCount + rCount;
+  }
+
+  public boolean containsNode(int value) {
+    return containsNode(value, root);
+  }  
+  private boolean containsNode(int value, TreeNode current) {
+    // your code goes here
+    // hint: base case...if the node is null, it does not contain the value
+    if (current == null)
+      return false;
+    if(current.myValue == value)
+      return true;
+    boolean lBool = containsNode(value, current.left);
+    boolean rBool = containsNode(value, current.right);
+    return lBool || rBool;
+  }
+
+  public int findMax() {
+    return findMax(root);
+  }  
+  private int findMax(TreeNode current) {
+    //assuming all nodes have values greater than -1000
+    int max = -1000;
+    if(current == null)
+      return max;
+    int lMax = findMax(current.left);
+    int rMax = findMax(current.right);
+    return Math.max(current.myValue, Math.max(lMax, rMax));
+  }
+
+  public int numLeaves() {
+    return numLeaves(root);
+  }
+  private int numLeaves(TreeNode current) {
+    if(current.left == null && current.right == null) {
+      // we are a leaf
+      return 1;
+    }
+
+    int leafCount = 0;
+
+    if(current.left != null)
+      leafCount += numLeaves(current.left);
+
+    if(current.right != null)
+      leafCount += numLeaves(current.right);
+
+    return leafCount;
+  }
+
+  public int levelCount(int target) {
+    return levelCount(root, target);
+  }
+
+  /**
+   * Returns number of nodes at specified level in t, where level >= 0.
+   * @param level specifies the level, >= 0
+   * @param t is the tree whose level-count is determined
+   * @return number of nodes at given level in t
+   */
+  public int levelCount(TreeNode t, int level){
+    if(t == null) {
+      return 0;
+    }
+
+    if(level == 0) {
+      return 1;
+    }
+
+    int nodeCount = 0;
+
+    nodeCount += levelCount(t.left, level - 1);
+    nodeCount += levelCount(t.right, level - 1);
+
+
+    return nodeCount;
+
+  }
+
+  public boolean hasPathSum(int target) {
+    return hasPathSum(root, target);
+  }
+  /**
+   * Return true if and only if t has a root-to-leaf path that sums to target.
+   * @param t is a binary tree
+   * @param target is the value whose sum is searched for on some root-to-leaf path
+   * @return true if and only if t has a root-to-leaf path summing to target
+   */
+  private boolean hasPathSum(TreeNode current, int target) {
+    if(current == null)
+      return false;
+
+    if(current.left == null && current.right == null) {
+      if(target == current.myValue) {
+        return true;
+      }
+    }
+
+    boolean rightPath = hasPathSum(current.right, target - current.myValue);
+    boolean leftPath = hasPathSum(current.left, target - current.myValue);
+
+    return rightPath || leftPath;
+  } 
+
+  public int findK(int k) {
+    return findK(root, k);
+  }
+
+  private int findK(TreeNode current, int k) {
+    if(current == null) {
+      return 0;
+    }
+    if(current.left == null && current.right == null) {
+      k--;
+      if(k == 0) {
+        return current.myValue;
+      }
+    } else {
+      int val = findK(current.left, k);
+      if(val != -1) {
+        return val;
+      }
+      k = k - countNodes(current.left);
+      k--;
+      if(k == 0)
+        return current.myValue;
+      return findK(current.right, k);
+    }
+
+
+    return -1;
+
+  } 
+
+  public static int height(TreeNode t){
+
+    if (t == null) return 0;
+    return 1 + Math.max(height(t.left), height(t.right));
+  } 
+
+  public static int diameter(TreeNode t) {
+
+    if (t == null)  return 0;
+
+    int leftD  = diameter(t.left);
+    int rightD = diameter(t.right);
+    int rootD  = height(t.left) + height(t.right) + 1;
+
+    return Math.max(rootD, Math.max(leftD, rightD));
+  }
+
+  /**
+   * Return both height and diameter of t, return height as
+   * value with index 0 and diameter as value with index 1
+   * in the returned array.
+   * @param t is a binary tree
+   * @return array containing both height (index 0) and diameter (index 1)
+   */
+  public static int[] diameterHelper (TreeNode t) {
+
+    int[] ret = new int[2];   // return this array
+
+    if (t == null) {
+      ret[0] = 0;   // height is 0
+      ret[1] = 0;   // and diameter is 0
+      return ret;
+    }
+    int[] left =  diameterHelper(t.left);
+    int[] right = diameterHelper(t.right);
+
+    ret[0] = 1 + Math.max(left[0],right[0]);  // this is height
+
+    // fill in value for ret[1] below
+
+    //FIX THIS
+    ret[1] = Math.max((right[0] + left[0] + 1), Math.max(left[1], right[1]));
+
+    return ret;
+
+  }
+
+  public static int diameterTwo(TreeNode t) {
+    int[] ret = diameterHelper(t);
+    return ret[1];
+  }
+
+  /**
+   * Returns true if s and t are isomorphic, i.e., have same shape.
+   * @param s is a binary tree (not necessarily a search tree)
+   * @param t is a binary tree
+   * @return true if and only if s and t are isomorphic
+   */
+
+  public static boolean isIsomorphic(TreeNode s, TreeNode t) {
+    if(s == null && t == null) {
+      return true;
+    }
+    if(s == null || t == null) {
+      return false;
+    }
+
+    boolean leftIso = isIsomorphic(s.left, t.left);
+    boolean rightIso = isIsomorphic(s.right, t.right);
+
+    return leftIso && rightIso;
+  }
+
+  /**
+   * Returns true if s and t are quasi-isomorphic, i.e., have same quasi-shape.
+   * @param s is a binary tree (not necessarily a search tree)
+   * @param t is a binary tree
+   * @return true if and only if s and t are quasi-isomporphic
+   */
+  public static boolean isQuasiIsomorphic(TreeNode s, TreeNode t) {
+    if(s == null && t == null) {
+      return true;
+    }
+    if(s == null || t == null) {
+      return false;
+    }
+
+    boolean leftQIso = isQuasiIsomorphic(s.left, t.left);
+    boolean rightQIso = isQuasiIsomorphic(s.right, t.right);
+
+    if(leftQIso && rightQIso)
+      return true;
+
+    leftQIso = isQuasiIsomorphic(s.left, t.right);
+    rightQIso = isQuasiIsomorphic(s.right, t.left);
+
+    return leftQIso && rightQIso;
+
+  }
+
+
+
+  public static void main(String[] args) {
+    BST bst = new BST();
+    int[] data = {6,8,2,4,1,7,5,3,9};
+    for(int i: data)
+      bst.add(i);
+    System.out.println(bst.toString());
+    System.out.printf("Number of leaves: %d\n", bst.numLeaves()); // 5
+    System.out.printf("Number of nodes on level 2: %d\n", bst.levelCount(2)); // 4
+    System.out.println("Has path sum 17: " + bst.hasPathSum(17));//true
+    System.out.println("Has path sum 10: " + bst.hasPathSum(10));//false
+    System.out.printf("The value in node 5 is: %d\n", bst.findK(5)); // 5
+
+    int[] dataOne = {10,2,1,7,6,15,14,13}; // isomorphic to 3
+    int[] dataTwo = {10,1,2,3,15,11,12,17}; //quasi-isomorphic to 1 & 3
+    int[] dataThree = {11,3,2,8,7,16,15,14}; // isomorphic to 1
+    BST one = new BST();
+    BST two = new BST();
+    BST three = new BST();
+    for(int i: dataOne)
+      one.add(i);
+    for(int i: dataTwo)
+      two.add(i);
+    for(int i: dataThree)
+      three.add(i);
+
+    System.out.println(diameter(one.root)); // 7
+    System.out.println(diameterTwo(one.root)); // also 7
+    System.out.println(isIsomorphic(one.root, three.root)); //true
+    System.out.println(isQuasiIsomorphic(one.root, two.root)); //true
+  }
+}