Java实现BinaryTree

package binaryTree;//BinaryTree.java public class BinaryTree {// Root node pointer. Will be null for an empty tree.private Node root;/* * 一个root具有 Node left; Node right; int data; 属性 *//* * --Node-- The binary tree is built using this nested node class. Each node * stores one data element, and has left and right sub-tree pointer which * may be null. The node is a "dumb" nested class -- we just use it for * storage; it does not have any methods. */private class Node {Node left;Node right;int data;Node(int newData) {left = null;right = null;data = newData;}}/** * Creates an empty binary tree -- a null root pointer. */public void BinaryTree() {root = null;}/** * Returns true if the given target is in the binary tree. Uses a recursive * helper. */public boolean lookup(int data) {return (lookup(root, data));}/** * Recursive lookup -- given a node, recur down searching for the given * data. */private boolean lookup(Node node, int data) {if (node == null) {return (false);}if (data == node.data) {return (true);} else if (data < node.data) {return lookup(node.left, data);} else {return (lookup(node.right, data));}}/** * Inserts the given data into the binary tree. Uses a recursive helper. */public void insert(int data) {root = insert(root, data);}/** * Recursive insert -- given a node pointer, recur down and insert the given * data into the tree. Returns the new node pointer (the standard way to * communicate a changed pointer back to the caller). */private Node insert(Node node, int data) {if (node == null) {node = new Node(data);} else {if (data <= node.data) {node.left = insert(node.left, data);} else {node.right = insert(node.right, data);}}return (node); // in any case, return the new pointer to the caller}// ///////////////////////////////////////////////////////////////////////////////////////////////////////////* * print the Node value in "inorder" order uses a recursive helper to do the * traversal */public void printInorder() {printInorder(root);System.out.println();}private void printInorder(Node root) {if (root == null) {return;}// left , node itself , rightprintInorder(root.left);System.out.print(root.data + " ");printInorder(root.right);}// //////////////////////////////////////////////////////////////////////////////////////////////////////////////** * Prints the node values in the "postorder" order. Uses a recursive helper * to do the traversal. */public void printPostorder() {printPostorder(root);System.out.println();}public void printPostorder(Node node) {if (node == null)return;// first recur on both subtreesprintPostorder(node.left);printPostorder(node.right);// then deal with the nodeSystem.out.print(node.data + " ");}public void printPreorder() {printPreorder(root);System.out.println();}private void printPreorder(Node node) {// TODO Auto-generated method stubif (node == null) {return;}System.out.print(node.data + " ");printPreorder(node.left);printPreorder(node.right);}// ///////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////建树///////////////////////////////////////** * Build 123 using three pointer variables. */public void build123a() {root = new Node(3);Node lChlid = new Node(1);Node rChild = new Node(3);root.left = lChlid;root.right = rChild;}/** * Build 123 using only one pointer variable. */public void build123b() {root = new Node(2);root.left = new Node(1);root.right = new Node(3);}/** * Build 123 by calling insert() three times. Note that the '2' must be * inserted first. */public void build123c() {root = null;root = insert(root, 2);root = insert(root, 1);root = insert(root, 3);root = insert(root, 5);root = insert(root, 11);root = insert(root, 4);root = insert(root, 23);root = insert(root, 11);root = insert(root, 22);}/** * Returns the number of nodes in the tree. Uses a recursive helper that * recurs down the tree and counts the nodes. */public int size() {return (size(root));}private int size(Node root) {if (root == null) {return 0;} else {return (size(root.left) + size(root.right) + 1);}}// //////////////////////////////max depth//////////////////////////////////** * Returns the max root-to-leaf depth of the tree. Uses a recursive helper * that recurs down to find the max depth. */public int maxDepth() {return (maxDepth(root));}private int maxDepth(Node root) {if (root == null) {return 0;} else {int lMaxDepth = maxDepth(root.left);int rMaxDepth = maxDepth(root.right);// use the larger + 1return Math.max(lMaxDepth, rMaxDepth) + 1;}}// /////////////////////////////////////////////////** * Finds the min value in a non-empty binary search tree. */public int minValue() {return (minValue(root));}// 最小值在最左子树最左的孩子private int minValue(Node root) {Node current = root;while (current.left != null) {current = current.left;}return current.data;}/** * Finds the min value in a non-empty binary search tree. */public int maxValue() {return (maxValue(root));}// 最大值在最右子树最右的孩子private int maxValue(Node root) {Node current = root;while (current.right != null) {current = current.right;}return current.data;}// ///////////////////////// //////////////////////////////////////////////////////////////////** * Given a binary tree, prints out all of its root-to-leaf paths, one per * line. Uses a recursive helper to do the work. */public void printPaths() {int[] path = new int[1000];printPaths(root, path, 0);}/** * Recursive printPaths helper -- given a node, and an array containing the * path from the root node up to but not including this node, prints out all * the root-leaf paths. */private void printPaths(Node node, int[] path, int pathLen) {if (node == null)return;// append this node to the path arraypath[pathLen] = node.data;pathLen++;// it's a leaf, so print the path that led to hereif (node.left == null && node.right == null) {printArray(path, pathLen);} else {// otherwise try both subtreesprintPaths(node.left, path, pathLen);printPaths(node.right, path, pathLen);}}/** * Utility that prints ints from an array on one line. */private void printArray(int[] ints, int len) {for (int i = 0; i < len; i++) {System.out.print(ints[i] + " ");}System.out.println();}// /////////////////////////////////////////////////////////////////** * Changes the tree into its mirror image. * * So the tree... 4 / / 2 5 / / 1 3 * * is changed to... 4 / / 5 2 / / 3 1 * * Uses a recursive helper that recurs over the tree, swapping the * left/right pointers. */public void mirror() {mirror(root);}private void mirror(Node node) {if (node != null) {// do the sub-treesmirror(node.left);mirror(node.right);// swap the left/right pointersNode temp = node.left;node.left = node.right;node.right = temp;}}// ////////////////////////////////////////////////////////** * Changes the tree by inserting a duplicate node on each nodes's .left. * * * So the tree... 2 / / 1 3 * * Is changed to... 2 / / 2 3 / / 1 3 / 1 * * Uses a recursive helper to recur over the tree and insert the duplicates. */public void doubleTree() {doubleTree(root);}private void doubleTree(Node node) {Node oldLeft;if (node == null)return;// do the subtreesdoubleTree(node.left);doubleTree(node.right);// duplicate this node to its leftoldLeft = node.left;node.left = new Node(node.data);node.left.left = oldLeft;}// ////////////////////////////////////////////////////////////////////* * Compares the receiver to another tree to see if they are structurally * identical. */public boolean sameTree(BinaryTree other) {return (sameTree(root, other.root));}/** * Recursive helper -- recurs down two trees in parallel, checking to see if * they are identical. */boolean sameTree(Node a, Node b) {// 1. both empty -> trueif (a == null && b == null)return (true);// 2. both non-empty -> compare themelse if (a != null && b != null) {return (a.data == b.data && sameTree(a.left, b.left) && sameTree(a.right, b.right));}// 3. one empty, one not -> falseelsereturn (false);}// /////////////////////////////////////////////////////////////////////////** * For the key values 1...numKeys, how many structurally unique binary * search trees are possible that store those keys? Strategy: consider that * each value could be the root. Recursively find the size of the left and * right subtrees. */public static int countTrees(int numKeys) {if (numKeys <= 1) {return (1);} else {// there will be one value at the root, with whatever remains// on the left and right each forming their own subtrees.// Iterate through all the values that could be the root...int sum = 0;int left, right, root;for (root = 1; root <= numKeys; root++) {left = countTrees(root - 1);right = countTrees(numKeys - root);// number of possible trees with this root == left*rightsum += left * right;}return (sum);}}// /////////////////////////////////////////////////////////////////////////////////////** * Tests if a tree meets the conditions to be a binary search tree (BST). */public boolean isBST() {return (isBST(root));}/** * Recursive helper -- checks if a tree is a BST using minValue() and * maxValue() (not efficient). */private boolean isBST(Node node) {if (node == null)return (true);// do the subtrees contain values that do not// agree with the node?if (node.left != null && maxValue(node.left) > node.data)return (false);if (node.right != null && minValue(node.right) <= node.data)return (false);// check that the subtrees themselves are okreturn (isBST(node.left) && isBST(node.right));}// ////////////////////////////////////////////////14. isBST2() Solution// (Java)/** * Tests if a tree meets the conditions to be a binary search tree (BST). * Uses the efficient recursive helper. */public boolean isBST2() {return (isBST2(root, Integer.MIN_VALUE, Integer.MAX_VALUE));}/** * Efficient BST helper -- Given a node, and min and max values, recurs down * the tree to verify that it is a BST, and that all its nodes are within * the min..max range. Works in O(n) time -- visits each node only once. */private boolean isBST2(Node node, int min, int max) {if (node == null) {return (true);} else {// left should be in range min...node.databoolean leftOk = isBST2(node.left, min, node.data);// if the left is not ok, bail outif (!leftOk)return (false);// right should be in range node.data+1..maxboolean rightOk = isBST2(node.right, node.data + 1, max);return (rightOk);}}public boolean contain(int data) {return contain(root, data);}private boolean contain(Node node, int data) {if (node == null) {return false;}Node current = node;//用迭代while (current != null) {if (current.data == data) {return true;} else if (data <= current.data) {current = current.left;} else if (data > current.data) {current = current.right;}}return false;}}