二叉查找树

最新推荐文章于 2025-05-19 10:07:58 发布

原创最新推荐文章于 2025-05-19 10:07:58 发布 · 293 阅读

CC 4.0 BY-SA版权

本文介绍了一个通用的二叉搜索树（Binary Search Tree, BST）的Java实现，包括节点的定义、插入、查找、遍历等核心操作，并提供了删除节点的详细步骤，特别是当被删除节点有两个子节点时的情况。

package com.study.arithmetic;

public class BinTree<T extends Comparable<T>> {

   class Node {
       public Node(T value) {
           this.value = value;
       }
       T value;
       Node left;
       Node right;
       Node parent;
   }

   private Node root;

   //遍历
   public void inOrderTreeWalk(Node node) {
       if(node != null) {
           inOrderTreeWalk(node.left);
           System.out.println(node.left.value);
           inOrderTreeWalk(node.right);
       }
   }

   //递归查找
   public Node treeSearch(Node node, T t) {
       if(node == null || node.value.compareTo(t) == 0)
           return node;
       if(t.compareTo(node.value) < 0)
           return treeSearch(node.left, t);
       else
           return treeSearch(node.right, t);
   }

   //非递归查找
   public Node iterativeTreeSearch(T t) {
       Node node = root;
       while(node != null && node.value.compareTo(t) != 0) {
           if(node.value.compareTo(t) < 0)
               node = node.left;
           else
               node = node.right;
       }
       return node;
   }

   //最小值
   public Node treeMinimum(Node node) {
       while(node != null)
           node = node.left;
       return node;
   }

   //最大值
   public Node treeMaximum() {
       Node node = root;
       while(node.right != null)
           node = node.right;
       return node;
   }

   //插入
   public void treeInsert(T t) {
       Node tNode = new Node(t);
       Node node = root;
       Node parentNode = null;
       while(node != null) {
           parentNode = node;
           if(t.compareTo(node.value) < 0)
               node = node.left;
           else
               node = node.right;
       }
       if(parentNode == null)
           root = tNode;
       else if(t.compareTo(parentNode.value) < 0)
           parentNode.left = tNode;
       else
           parentNode.right = tNode;
       tNode.parent = parentNode;
   }

   //直接后驱
   public Node treeSuccessor(Node node) {
       if(node.right != null)
           return treeMinimum(node.right);
       Node pNode = node.parent;
       while(pNode != null && node.value.equals(pNode.right.value)) {
           node = pNode;
           pNode = pNode.parent;
       }
       return pNode;
   }

   //删除
   public void treeDelete(T t) {

       Node tNode = iterativeTreeSearch(t);
       Node changeNode = null;
       if(tNode != null) {
           if(tNode.left == null || tNode.right == null) {
               //待删除节点没有有2个孩子
               changeNode = tNode;
           } else {
               //待删除节点拥有2个孩子
               changeNode = treeSuccessor(tNode);
           }
           //用来存放改变的节点的孩子节点。
           Node tmpNode = null;
           if(changeNode.left != null)
               tmpNode = changeNode.left;
           else
               tmpNode = changeNode.right;
           if(tmpNode != null)
               tmpNode.parent = changeNode.parent;
           if(changeNode.parent == null)
               root = tNode;
           else if(changeNode == changeNode.parent.left)
               changeNode.parent.left = tmpNode;
           else
               changeNode.parent.right = tmpNode;
           if (!tNode.value.equals(changeNode.value))
               tNode.value = changeNode.value;
       }
   }
}