二叉树

package wxhua.data.structures.tree;

/**
 * 二叉树
 *  优点: 能够快速 的插入 删除 读取
 *  但是,如果 插入的 是有序数据,或者是 倒序数据...结果 二叉树 就失去了它的作用 此时称为 不平衡树
 * @author Administrator
 *
 */
public class TwoXTree {

 public Node root;
 
 public void insert(int data) {
  Node node = new Node(data);
  if(root == null)
   root = node;
  else {
   Node current = root;
   Node parent;
   while(true) {
    parent = current;
    if(data < current.data) {
     current = current.left;
     if(current == null) {
      parent.left = node;
      return ;
     }
    } else {
     current = current.right;
     if(current == null) {
      parent.right = node;
      return;
     }
    }
   }
  }
 }
 
 public Node min() {
  Node current = root;
  Node last = null;
  while(current != null) {
   last = current;
   current = current.left;
  }
  return last;
 }
 
 public Node max() {
  Node current = root;
  Node last = null;
  while(current != null) {
   last = current;
   current = current.right;
  }
  return last;
 }
 
 public boolean delete(int data) {
  Node current = root;
  Node parent = root;
  boolean isleftChild = true;
  
  while(current.data != data) {
   parent = current;
   if(data < current.data) {
    isleftChild = true;
    current = current.left;
   } else {
    isleftChild = false;
    current = current.right;
   }
   //没有找到要删除的数据...
   if(current == null)
    return false;
  }
  
  if(current.left == null && current.right == null) {
   if(current == root) {
    root = null;
   } else if(isleftChild) {
    parent.left = null;
   } else {
    parent.right = null;
   }
  } else if(current.right == null) {
   if(current == root)
    root = current.left;
   else if(isleftChild)
    parent.left = current.left;
   else
    parent.right = current.left;
  } else if(current.left == null) {
   if(current == root)
    root = current.right;
   else if(isleftChild)
    parent.left = current.right;
   else
    parent.right = current.right;
  } else {
   Node successor = getSuccessor(current);
   
   if(current == root)
    root = successor;
   else if(isleftChild)
    parent.left = successor;
   else
    parent.right = successor;
   //最后记得 将 后续节点的 左节点 设成 删除节点 的左节点
   successor.left = current.left;
  }
  
  return true;
 }

 //拿到后续节点...
 private Node getSuccessor(Node delNode) {
  Node successorParent =delNode;
  Node successor = delNode;
  Node current = delNode.right;
  while(current != null) {
   successorParent = successor;
   successor = current;
   current = current.left;
  }
  
  //如果 后续节点 不是 删除节点的右节点 ...
  if(successor != delNode.right) {
   //将后续节点的父节点 的左节点 指向后续节点的右节点
   successorParent.left = successor.right;
   //将 后续节点 的右节点 指向 删除节点的右节点...
   successor.right = delNode.right;
  }
  //如果 后续节点 是删除节点的 右节点...则返回右节点
  return successor;
 }
 
 public Node find(int key) {
  Node current = root;
  while(current.data != key) {
   if(key < current.data)
    current = current.left;
   else
    current = current.right;
   if(current == null)
    return null;
  }
  return current;
 }
 
 public void display(Node node) {
  if(node != null) {
   display(node.left);
   System.out.print(node.data + "\t");
   display(node.right);
  }
 }
 
 public static void main(String[] args) {
  TwoXTree tree = new TwoXTree();
  
  tree.insert(44);
  tree.insert(11);
  tree.insert(22);
  tree.insert(66);
  tree.insert(88);
  tree.insert(55);
  tree.insert(10);
  tree.insert(23);
  tree.insert(43);
  
  Node n = tree.find(22);
  System.out.println("find: " + n.data);
  
  tree.display(tree.root);
  System.out.println();
  
  Node min = tree.min();
  System.out.println("min: " + min.data);
  
  Node max = tree.max();
  System.out.println("max: " + max.data);
  
  tree.delete(23);
  System.out.print("after delete :\t ");
  tree.display(tree.root);
 
  
 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

package wxhua.data.structures.tree;

public class Node {
 
 public Node(int data) {
  this.data = data;
 }

 public int data;
 
 public Node left;
 
 public Node right;
 
}