二叉树（java实现）

一、树的术语       ————>>如下图

根：树的根节点。

路径：从一个节点到另一个 节点所经过的“路”（说白了就是两个点的连线）。

父节点、子节点。叶节点：在所有节点中，每两个节点之间都有连线，（除了根外）上个节点就是下个节点的父节点；反过来，下个节点就是上个节点的子节点；而没有子节点的节点就是叶节点。

子树：每个节点都可以成为“子树”的根，它和它所包含之下的节点都可以组成一个子树，如上图F、I、J，F就是根，I、J为子树的叶节点。

访问：当流程到达某个节点时，就可以认为是“访问”了该节点，通常是在此做了某种操作（如显示该节点或查看某个字段等），如果只是通过，不认为是访问。

遍历：遵循某种特定的顺序访问树中所有节点。

层：如上图，根属于0层，依次往下走。

二、以下是二叉树的一个实例（Java实现）

 

package mtest;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;

class Node {
 public int iData;
 public double dData;
 public Node leftChild;
 public Node rightChild;

 public void displayNode() {
  System.out.print("{");
  System.out.print("iData");
  System.out.print(",");
  System.out.print(dData);
  System.out.print("}");
 }
}

class Tree {
 private Node root;

 public Tree() {
  root = null;
 }

 public Node find(int key) {
  Node current = root;
  while (current.iData != key) {
   if (key < current.iData) {
    current = current.leftChild;
   } else {
    current = current.rightChild;
   }
   if (current == null) {
    return null;
   }
  }
  return current;

 }
    //插入一个节点
 public void insert(int id, double dd) {
  Node newNode = new Node();
  newNode.iData = id;
  newNode.dData = dd;
  if (root == null) {
   root = newNode;
  } else {
   Node current = root;
   Node parent;
   while (true) {
    parent = current;
    if (id < current.iData) {
     current = current.leftChild;
     if (current == null) {
      parent.leftChild = newNode;
      return;
     }
    } else {
     current = current.rightChild;
     if (current == null) {
      parent.rightChild = newNode;
      return;
     }
    }
   }
  }
 }
    //删除节点
 public boolean delete(int key) {
  Node current = root;
  Node parent = root;
  boolean isLeftChild = true;
  while (current.iData != key) {
   parent = current;
   if (key < current.iData) {
    isLeftChild = true;
    current = current.leftChild;
   } else {
    isLeftChild = false;
    current = current.rightChild;
   }
   if (current == null) {
    return false;
   }
  }
  if (current.leftChild == null && current.rightChild == null) {
   if (current == root) {
    root = null;
   } else if (isLeftChild) {
    parent.leftChild = null;
   } else {
    parent.rightChild = null;
   }
  } else if (current.rightChild == null) {
   if (current == root) {
    root = current.leftChild;
   } else if (isLeftChild) {
    parent.leftChild = current.leftChild;
   } else {
    parent.rightChild = current.rightChild;
   }
  } else if (current.leftChild == null) {
   if (current == root) {
    root = current.rightChild;
   } else if (isLeftChild) {
    parent.leftChild = current.rightChild;
   } else {
    parent.rightChild = current.rightChild;
   }
  } else {
   Node successor = getSuccessor(current);
   if (current == root) {
    root = successor;
   } else if (isLeftChild) {
    parent.leftChild = successor;
   } else {
    parent.rightChild = successor;
   }
   successor.leftChild = current.leftChild;
  }
  return true;
 }

 private Node getSuccessor(Node delNode) {
  Node successorParent = delNode;
  Node successor = delNode;
  Node current = delNode.rightChild;
  while (current != null) {
   successorParent = successor;
   successor = current;
   current = current.leftChild;
  }
  if (successor != delNode.rightChild) {
   successorParent.leftChild = successor.rightChild;
   successor.rightChild = delNode.rightChild;
  }
  return successor;
 }

 public void traverse(int traverseType) {
  switch (traverseType) {
  case 1:
   System.out.print("\nPreorder traversal:");
   preOrder(root);
   break;
  case 2:
   System.out.print("\nInorder traversal:");
   inOrder(root);
   break;
  case 3:
   System.out.print("\nPostorder traversal:");
   postOrder(root);
   break;
  }
  System.out.println();
 }

 private void preOrder(Node localRoot) {
  if (localRoot != null) {
   System.out.print(localRoot.iData + " ");
   preOrder(localRoot.leftChild);
   preOrder(localRoot.rightChild);
  }
 }
    //遍历树
 private void inOrder(Node localRoot) {
  if (localRoot != null) {
   inOrder(localRoot.leftChild);
   System.out.print(localRoot.iData + " ");
   inOrder(localRoot.rightChild);
  }
 }

 private void postOrder(Node localRoot) {
  if (localRoot != null) {
   postOrder(localRoot.leftChild);
   postOrder(localRoot.rightChild);
   System.out.print(localRoot.iData + " ");
  }
 }

 @SuppressWarnings({ "unchecked", "rawtypes" })
 public void displayTree() {
  Stack globalStack = new Stack();
  globalStack.push(root);
  int nBlacks = 32;
  boolean isRowEmpty = false;
  System.out.println("================================");
  while (isRowEmpty == false) {
   Stack localStack = new Stack();
   isRowEmpty = true;
   for (int j = 0; j < nBlacks; j++) {
    System.out.print(" ");
   }
   while (globalStack.isEmpty() == false) {
    Node temp = (Node) globalStack.pop();
    if (temp != null) {
     System.out.print(temp.iData);
     localStack.push(temp.leftChild);
     localStack.push(temp.rightChild);
     if (temp.leftChild != null || temp.rightChild != null) {
      isRowEmpty = false;
     }
    } else {
     System.out.print("----");
     localStack.push(null);
     localStack.push(null);
    }
    for (int j = 0; j < nBlacks * 2 - 2; j++) {
     System.out.print(' ');
    }
   }
   System.out.println();
   nBlacks /= 2;
   while (localStack.isEmpty() == false) {
    globalStack.push(localStack.pop());
   }
  }
  System.out.println("===============================");
 }
}

public class TreeApp {
 public static void main(String[] args) throws IOException {
  int value;
  Tree theTree = new Tree();
  theTree.insert(50, 1.5);
  theTree.insert(20, 2.5);
  theTree.insert(55, 1.4);
  theTree.insert(34, 5.6);
  theTree.insert(10, 1.1);
  theTree.insert(20, 1.2);
  theTree.insert(30, 1.3);
  theTree.insert(40, 1.4);
  theTree.insert(50, 1.5);
  theTree.insert(60, 1.6);
  theTree.insert(70, 1.7);
  theTree.insert(80, 1.8);
  theTree.insert(90, 1.9);
  theTree.insert(51, 1.0);
  theTree.insert(52, 2.5);
  theTree.insert(53, 3.5);
  theTree.insert(54, 4.5);
  theTree.insert(55, 5.5);
  while (true) {
   System.out.print("Enter first letter of show,");
   System.out.print("insert,find,delete,or traverse:");
   int choice = getChar();
   switch (choice) {
   case 's':
    theTree.displayTree();
    break;
   case 'i':
    System.out.print("Enter value to insert:");
    value = getInt();
    theTree.insert(value, value + 0.9);
    break;
   case 'f':
    System.out.print("Enter value to find:");
    value = getInt();
    Node found = theTree.find(value);
    if (found != null) {
     System.out.print("Found:");
     found.displayNode();
     System.out.print("\n");
    } else {
     System.out.print("Could not find");
    }
    System.out.print(value + "\n");
    break;
   case 'd':
    System.out.print("Enter value to delete:");
    value = getInt();
    boolean didDelete = theTree.delete(value);
    if (didDelete) {
     System.out.print("Deleted" + value + "\n");
    } else {
     System.out.print("Could not delete");
    }
    System.out.print(value + '\n');
    break;
   case 't':
    System.out.print("Enter type 1,2 or 3:");
    value = getInt();
    theTree.traverse(value);
    break;
   default:
    System.out.print("Innalid entry\n");
   }
  }
 }

 public static String getString() throws IOException {
  InputStreamReader isr = new InputStreamReader(System.in);
  BufferedReader br = new BufferedReader(isr);
  String s = br.readLine();
  return s;
 }

 public static char getChar() throws IOException {
     String s = getString();
  return s.charAt(0);
 }

 public static int getInt() throws IOException {
  String s = getString();
  return Integer.parseInt(s);
 }

}