数据结构学习笔记24 二叉树

public class Node {
   public int id;
   public double data;
   public Node leftNode;
   public Node rightNode;
   public void displayNode(){
	   System.out.println("("+id+","+data+")");
   }
   
   public Node(int a,double value){
	   id=a;
	   data=value;
   }
}

import java.util.*;
public class Tree {
   private Node root;
   public Tree(){
	   root=null;
   }
   
   public void insert(int a,double dd){
	   Node newNode=new Node(a,dd);
	   if(root==null) 
		   root=newNode;
	   else{
		   Node current=root;
		   Node parent;
		   while(true){
			   parent=current;
			   if(newNode.id<current.id) {
				   current=parent.leftNode;
				   if(current==null) {
				   parent.leftNode=newNode;
				   return;
				   }
			   }
			   else{
				   current=parent.rightNode;
				   if(current==null) {
				   parent.rightNode=newNode;
				   return;
				   }
			   }
		   }
	   }
   }
   
   public boolean delete(int key){   //删除时，如果右子树的左子树存在，用其的最下一层左侧替代，如果不存在
	   Node current=root;
	   Node parent=root;
	   boolean isleftChild=true;
	   while(current.id!=key){
		   parent=current;
		   if(key<current.data){
			   isleftChild=true;
			   current=current.leftNode;
		   }else{
			   isleftChild=false;
			   current=current.rightNode;
		   }
		   if(current==null) return false;
	   }
	   if(current.leftNode==null &¤t.rightNode==null){
		   //删除的是叶子结点
		   if(current==root) root=null; //删除根，没有子结点
		   else if(isleftChild==true){
		       parent.leftNode=null;
		   }else{
			   parent.rightNode=null;
		   }
	   }else if(current.rightNode==null){ //删除的节点只有一个左子节点
		   if(current==root)  root=current.leftNode;
		   else if(isleftChild==true) {  //要删除的节点是父节点的左节点
		       parent.leftNode=current.leftNode;
		   }
		   else parent.rightNode=current.leftNode;
	   }else if(current.leftNode==null){ //删除的节点只有一个右子节点
		   if(current==root) root=current.rightNode;
		   else if(isleftChild==true){
			   parent.leftNode=current.rightNode;
		   }else parent.rightNode=current.rightNode;
	   }else{ //左右节点都存在
		   Node successor=getSuccessor(current);
		   if(current==root) root=current;
		   else if(isleftChild) parent.leftNode=successor;
		   else parent.rightNode=successor;
		   successor.leftNode=current.leftNode;
	   }
	   return true;
   }
   
   
   //向右子树下找继承节点
   public Node getSuccessor(Node delNode){  //获取继承节点
	     Node successorParent=delNode;
	     Node successor=delNode;
	     Node current=delNode.rightNode;
	     while(current!=null){           //寻找继承者
	    	 successorParent=successor;
	    	 successor=current;
	    	 current=current.leftNode;
	     }
	     if(successor!=delNode.rightNode){  //继承者不是删除节点的右子节点
	    	 //特殊情况之一,如果继承者是最下层的左节点，不需要操作
	    	 successorParent.leftNode=successor.rightNode;
	    	 successor.rightNode=delNode.rightNode;//这句代码结合前面的successor.leftNode=current.leftNode;
	     }
	     return successor;
   }
   
   public Node findNode(int key){
	   Node current=root;
	   while(current.id!=key){
		   if(key<current.id){
			   current=current.leftNode;
		   }else{
			   current=current.rightNode;
		   }
		   if(current==null) return null; 
	   }
	   return current;
   }
   
   public void traverse(int type){
	   switch(type){
	   case 1:
		   System.out.println("从上到下，从左到右");
		   preOrder(root);
		   break;
	   case 2:
		   System.out.println("从下到上，从左到右");
		   inOrder(root);
		   break;
	   case 3:
		   System.out.println("从下到上，从右到左");
		   postOrder(root);
		   break;
	   }
   }
   
   public void preOrder(Node localRoot){ //从上到下，从左到右
	   if(localRoot!=null){
		   System.out.println(localRoot.id+" ");
		   preOrder(localRoot.leftNode);
		   preOrder(localRoot.rightNode);
	   }
   }
   
   public void inOrder(Node localRoot){ //从下到上，从左到右
	   if(localRoot!=null){
		   inOrder(localRoot.leftNode);
		   System.out.print(localRoot.id+" ");
		   inOrder(localRoot.rightNode);
	   }
   }
   
   public void postOrder(Node localRoot){ ////从下到上，从右到左
	   if(localRoot!=null){
		   postOrder(localRoot.leftNode);
		   postOrder(localRoot.rightNode);
		   System.out.print(localRoot.id+" ");
	   }
   }
   
   
   //看不懂是啥
   public void displaytree(){
	   Stack s=new Stack();
	   s.push(root);
	   int num=32;
	   boolean isempty=false;
	   System.out.println(".................");
	   while(isempty==false){
		   Stack localStack=new Stack();
		   isempty=true;
		   for(int j=0;j<num;j++)
			   System.out.print(" ");
		   while(s.isEmpty()==false){
			   Node t=(Node)s.pop();
			   if(t!=null){
				   System.out.print(t.id);
				   localStack.push(t.leftNode);
				   localStack.push(t.rightNode);
				   if(t.leftNode!=null || t.rightNode!=null)
					   isempty=false;
			   }else {
				   System.out.print("--");
				   localStack.push(null);
				   localStack.push(null);
			   }
			   for(int j=0;j<num*2-2;j++){
				   System.out.print(" ");
			   }
		   }
		   System.out.println();
		   num/=2;
		   while(localStack.isEmpty()==false){
			   s.push(localStack.pop());
		   }
	   }
	   System.out.println("...............");
   }
}

import java.io.*;

public class TreeApp {
  public static String getString() throws IOException{
	  InputStreamReader isr=new InputStreamReader(System.in);
	  BufferedReader br=new BufferedReader(isr);
	  return br.readLine();	  
  }
  
  public static char getchar() throws IOException{
	  return getString().charAt(0);
  }
  
  public static int getInt() throws IOException{
	  return Integer.parseInt(getString());
  }
  
  public static void main(String[] args){
	  //int value;
	  Tree theTree=new Tree();
	  theTree.insert(50, 2.3);
	  theTree.insert(25, 1.4);
	  theTree.insert(75, 1.7);
	  theTree.insert(12, 1.2);
	  theTree.insert(15, 2.9);
	  theTree.insert(23, 2.1);
	  theTree.insert(55, 2.2);
	  theTree.insert(20, 1.3);
	  theTree.traverse(1);
	  theTree.displaytree();
  }
}