java二叉树的增、删、查、前序遍历、中序遍历和后序遍历 算法 源代码

深圳装修网 

java二叉树的增、删、查、前序遍历、中序遍历和后序遍历

package com.datastructrue.lmy;

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.leftChild;
  }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=getSuccess(current);//删除节点，并返回该节点的后继节点
   if(current==root)
    root=successor;
   else if(isLeftChild)
    parent.leftChild=successor;
   else
    parent.rightChild=successor;
   successor.leftChild=current.leftChild;
  }
  return true;
 }
 private Node getSuccess(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+" ");
  }
 }
 public void displayTree(){
  Stack<Node> globalStack=new Stack<Node>();
  globalStack.push(root);
  int nBlanks=32;
  boolean isRowEmpty=false;
  System.out.println("===========================================================================");
  while(isRowEmpty==false){
   Stack<Node> localStack=new Stack<Node>();
   isRowEmpty=true;
   for(int j=0;j<nBlanks;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<nBlanks*2-2;j++) //????????????
     System.out.print(' ');
   }
   System.out.println();
   nBlanks/=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(25, 1.2);
  theTree.insert(75, 1.7);
  theTree.insert(12, 1.5);
  theTree.insert(37, 1.2);
  theTree.insert(43, 1.7);
  theTree.insert(30, 1.5);
  theTree.insert(33, 1.2);
  theTree.insert(87, 1.7);
  theTree.insert(93, 1.5);
  theTree.insert(97, 1.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("Cound 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("Invalid 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);
 }
}