详细的Java二进制排序树

一两个排序树定义

1. 二进制排序树的定义

二进制排序树也称为二进制搜索树. 它定义为: 二进制排序树是满足以下属性的空树或二进制树:

①如果左子树不为空，则左子树上所有节点的值小于根节点的值;

②如果右子树不为空，则右子树上所有节点的值大于根节点的值；

③左和右子树都是二叉排序树.

以上属性称为二进制排序树属性（BST属性），因此二进制排序树实际上是满足BST属性的二进制树.

2. 二进制排序树的属性

对二进制排序树进行中间顺序遍历，得到的中间顺序遍历序列是一个递增顺序的序列.

3. 插入二进制排序树

将新节点插入二进制排序树. 确保插入的二叉树仍然符合二叉排序树的定义.

插入过程

如果二进制排序树为空，则将要插入的节点* S作为根节点插入到空树中；

当它不为空时，将要插入的节点的键S->键与树根键t->键进行比较. 如果s->键= t->键，则无需插入. 如果将s->键键插入到根的左子树中，如果将s->键> t->键插入到根的右子树中. 子树中的插入过程与树中的插入过程相同. 这将继续进行，直到将节点* s作为新叶插入到二进制排序树中为止，或者直到发现树已经具有相同的关键字为止. 到目前为止.

4. 搜索二进制排序树

假设二进制排序树的根节点指针为root，给定键值为K，则搜索算法可以描述为:

①初始值: q =根；

②如果K = q->键，则搜索成功并且算法结束；

③否则，如果K 键且q的左子树不为空二叉排序树的遍历，则将q的左子树根发送给q并转到步骤②；否则，搜索将失败并且算法结束；

④否则，如果K> q->键且q的右子树不为空，则将q的右子树根发送给q并转到步骤②；否则，搜索将失败并且算法结束.

5. 删除二进制排序树

假设删除的节点是* p，并且其父节点是* f，并且不失一般性，令* p是* f的左子节点. 讨论了以下三种情况:

⑴如果节点* p是叶节点，则只需修改其父节点* f的指针.

⑵如果节点* p仅具有左侧子树PL或仅右侧子树PR，则只有PL或PR必须是其父节点的左侧子树.

⑶如果节点* p的左右子树不为空，则首先找到* p的中阶前任（或后继）节点* s（请注意* s在* p的左子树中最多右下角节点有一个空的右链域），则有两种方法: ①让* p的左子树直接链接到* p的父节点* p的左链，而* p的右边子树链接到* p的有序前任节点* s的右链. ②将* p替换为* p的中序前向节点* s（即，将* s的数据复制到* p中），并将* s的左子树链接到* s的父节点* q的左侧（或正确）.

6. 遍历二叉树

遍历二叉树的方法有以下三种:

（1）预遍历（DLR），首先访问根节点，然后遍历左侧子树二叉排序树的遍历，最后遍历右侧子树. 简短注释，从左到右.

（2）按顺序遍历（LDR），首先遍历左侧子树，然后访问根节点，最后遍历右侧子树. 简短说明，从左到右.

（3）后顺序遍历（LRD），首先遍历左侧子树，然后遍历右侧子树，最后访问根节点. 简短说明，从左到右.

第二，编写代码

1. 树节点类0的定义

package com.lin; 
/** 
 * 功能概要： 
 */ 
public class TreeNode { 
   
  public Integer data; 
   
  /*该节点的父节点*/ 
  public TreeNode parent; 
   
  /*该节点的左子节点*/ 
  public TreeNode left; 
   
  /*该节点的右子节点*/ 
  public TreeNode right; 
   
  public TreeNode(Integer data) { 
    this.data = data; 
     
  } 
 
  @Override 
  public String toString() { 
    return "TreeNode [data=" + data + "]"; 
  } 
     
} 

2. 二进制排序树的定义

package com.lin; 
 
/** 
 * 功能概要：排序/平衡二叉树 
 */ 
public class SearchTree { 
   
   public TreeNode root; 
    
   public long size; 
     
  /** 
   * 往树中加节点  
   * @param data 
   * @return Boolean 插入成功返回true 
   */ 
  public Boolean addTreeNode(Integer data) { 
 
    if (null == root) { 
      root = new TreeNode(data); 
      System.out.println("数据成功插入到平衡二叉树中"); 
      return true; 
    } 
 
    TreeNode treeNode = new TreeNode(data);// 即将被插入的数据 
    TreeNode currentNode = root; 
    TreeNode parentNode; 
 
    while (true) { 
      parentNode = currentNode;// 保存父节点 
      // 插入的数据比父节点小 
      if (currentNode.data > data) { 
        currentNode = currentNode.left; 
        // 当前父节点的左子节点为空 
        if (null == currentNode) { 
          parentNode.left = treeNode; 
          treeNode.parent = parentNode; 
          System.out.println("数据成功插入到二叉查找树中"); 
          size++; 
          return true; 
        } 
        // 插入的数据比父节点大 
      } else if (currentNode.data < data) { 
        currentNode = currentNode.right; 
        // 当前父节点的右子节点为空 
        if (null == currentNode) { 
          parentNode.right = treeNode; 
          treeNode.parent = parentNode; 
          System.out.println("数据成功插入到二叉查找树中"); 
          size++; 
          return true; 
        } 
      } else { 
        System.out.println("输入数据与节点的数据相同"); 
        return false; 
      } 
    }     
  } 
   
  /** 
   * @param data 
   * @return TreeNode 
   */ 
  public TreeNode findTreeNode(Integer data){ 
    if(null == root){ 
      return null; 
    } 
    TreeNode current = root; 
    while(current != null){ 
      if(current.data > data){ 
        current = current.left; 
      }else if(current.data < data){ 
        current = current.right; 
      }else { 
        return current; 
      } 
       
    } 
    return null; 
  } 
   
} 

只有一种方法可以在此处临时添加和查找

3，前后，遍历

package com.lin; 
 
import java.util.Stack; 
 
/** 
 * 功能概要： 
 */ 
public class TreeOrder { 
   
  /** 
   * 递归实现前序遍历 
   * @author linbingwen 
   * @since 2015年8月29日 
   * @param treeNode 
   */ 
  public static void preOrderMethodOne(TreeNode treeNode) { 
    if (null != treeNode) { 
      System.out.print(treeNode.data + " "); 
      if (null != treeNode.left) { 
        preOrderMethodOne(treeNode.left); 
      } 
      if (null != treeNode.right) { 
        preOrderMethodOne(treeNode.right); 
 
      } 
    } 
  } 
 
  /** 
   * 循环实现前序遍历 
   * @param treeNode 
   */ 
  public static void preOrderMethodTwo(TreeNode treeNode) { 
    if (null != treeNode) { 
      Stack<TreeNode> stack = new Stack<TreeNode>(); 
      stack.push(treeNode); 
      while (!stack.isEmpty()) { 
        TreeNode tempNode = stack.pop(); 
        System.out.print(tempNode.data + " "); 
        // 右子节点不为null,先把右子节点放进去 
        if (null != tempNode.right) { 
          stack.push(tempNode.right); 
        } 
        // 放完右子节点放左子节点，下次先取 
        if (null != tempNode.left) { 
          stack.push(tempNode.left); 
        } 
      } 
    } 
  } 
   
  /** 
   * 递归实现中序遍历 
   * @param treeNode 
   */ 
  public static void medOrderMethodOne(TreeNode treeNode){ 
    if (null != treeNode) {      
      if (null != treeNode.left) { 
        medOrderMethodOne(treeNode.left); 
      } 
      System.out.print(treeNode.data + " "); 
      if (null != treeNode.right) { 
        medOrderMethodOne(treeNode.right); 
      } 
    } 
     
  } 
   
  /** 
   * 循环实现中序遍历 
   * @param treeNode 
   */ 
  public static void medOrderMethodTwo(TreeNode treeNode){   
    Stack<TreeNode> stack = new Stack<TreeNode>();  
    TreeNode current = treeNode;  
    while (current != null || !stack.isEmpty()) {  
      while(current != null) {  
        stack.push(current);  
        current = current.left;  
      }  
      if (!stack.isEmpty()) {  
        current = stack.pop();  
        System.out.print(current.data+" ");  
        current = current.right;  
      }  
    }     
  } 
   
  /** 
   * 递归实现后序遍历 
   * @param treeNode 
   */ 
  public static void postOrderMethodOne(TreeNode treeNode){     
    if (null != treeNode) {    
      if (null != treeNode.left) { 
        postOrderMethodOne(treeNode.left); 
      } 
      if (null != treeNode.right) { 
        postOrderMethodOne(treeNode.right); 
      } 
      System.out.print(treeNode.data + " "); 
    } 
     
  } 
   
  /** 
   * 循环实现后序遍历 
   * @param treeNode 
   */ 
  public static void postOrderMethodTwo(TreeNode treeNode){ 
    if (null != treeNode) { 
      Stack<TreeNode> stack = new Stack<TreeNode>(); 
      TreeNode current = treeNode; 
      TreeNode rightNode = null; 
      while(current != null || !stack.isEmpty()) {  
        while(current != null) {  
          stack.push(current);  
          current = current.left;  
        }  
        current = stack.pop();  
        while (current != null && (current.right == null ||current.right == rightNode)) {  
          System.out.print(current.data + " ");  
          rightNode = current;  
          if (stack.isEmpty()){  
            System.out.println();  
            return;  
          }  
          current = stack.pop();  
        }  
        stack.push(current);  
        current = current.right;  
      }  
       
       
       
    } 
  } 
   
} 

4. 使用方法

package com.lin;  
/** 
 * 功能概要： 
*/ 
public class SearchTreeTest { 
 
  /** 
   * @param args   
   */ 
  public static void main(String[] args) { 
    SearchTree tree = new SearchTree(); 
    tree.addTreeNode(50); 
    tree.addTreeNode(80); 
    tree.addTreeNode(20); 
    tree.addTreeNode(60);   
    tree.addTreeNode(10); 
    tree.addTreeNode(30); 
    tree.addTreeNode(70); 
    tree.addTreeNode(90);   
    tree.addTreeNode(100); 
    tree.addTreeNode(40); 
    System.out.println("=============================="+"采用递归的前序遍历开始"+"=============================="); 
    TreeOrder.preOrderMethodOne(tree.root); 
    System.out.println(); 
    System.out.println("=============================="+"采用循环的前序遍历开始"+"=============================="); 
    TreeOrder.preOrderMethodTwo(tree.root); 
    System.out.println(); 
    System.out.println("=============================="+"采用递归的后序遍历开始"+"=============================="); 
    TreeOrder.postOrderMethodOne(tree.root); 
    System.out.println(); 
    System.out.println("=============================="+"采用循环的后序遍历开始"+"=============================="); 
    TreeOrder.postOrderMethodTwo(tree.root); 
    System.out.println(); 
    System.out.println("=============================="+"采用递归的中序遍历开始"+"=============================="); 
    TreeOrder.medOrderMethodOne(tree.root); 
    System.out.println(); 
    System.out.println("=============================="+"采用循环的中序遍历开始"+"=============================="); 
    TreeOrder.medOrderMethodTwo(tree.root); 
 
  } 
 
} 

输出:

类似地，搜索过程如下:

TreeNode node = tree.findTreeNode(100); 
System.out.println(node); 

结果正确

上面是对Java二进制排序树的详细介绍. 希望对大家学习Java编程有所帮助.

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-147591-1.html