Java实现数据结构---二叉树

树的定义

树是一种由连接着结点的数据结构,数据模型上的树可以看做是一棵倒挂的树木,有一个主干,下面是枝干、树叶。树的数据结构模型如下:
在这里插入图片描述
节点:上图的圆圈,比如A、B、C、D等都是表示节点,节点里面包含了存储的数据以及指向其它节点的地址引用。
:连接节点的线称为边,边表示节点的关联关系。一般从一个节点到另一个节点的唯一方法就是沿着一条顺着有边的道路前进,也就是引用。
树的常用语

  • :树的最顶端节点称为根,一棵树只有一个根。且根到任意一节点有且只有一条路径。
  • 父节点:每个节点(排除根)都恰好有一条边向上连接另一节点,上面这个节点就是下面节点的父节点。例如:A是B和C的父节点,B是D和E节点的父节点。
  • 子节点:每个节点都有可能存在一条或者多条边向下连接其他节点,下面节点就是上面节点的子节点。例如:B、C是A的子节点,D、E是B子节点。
  • 叶节点:没有子节点的节点称为“叶子节点”。例如:D、E和F都是叶节点。
  • 子树:每个节点都可以称为子树的“根”,它和它的所有子孙节点都包含在子树中。例如:在BDE子树中B是该子树的“根”。
  • 层次:从根开始定义,根为第一层(或者0层),根的子节点为第二层(或者1层),以此类推。

二叉树的定义

每个节点最多只有两个子节点的书被称为二叉树节点的两个节点分别称为:左子节点以及右子节点
满足存储数据规则(一个节点的左子节点比节点小,一个节点的右子节点比节点大)的为特殊的二叉树–>二叉搜索树。

二叉树模型如下:
在这里插入图片描述

二叉树的实现(二叉搜索树为例)

1. 二叉树节点类定义:

package com.xxliao.datastructure.tree.binary_tree;

/**
 * @author xxliao
 * @description: 二叉树的节点类
 * @date 2024/5/28 23:00
 */
public class Node {

    // 数据项
    public int data;

    // 左子节点
    public Node leftChildNode;

    // 右子节点
    public Node rightChildNode;

    // 构造方法
    public Node(int data) {
        this.data = data;
        leftChildNode = null;
        rightChildNode = null;
    }

    // 查看节点数据
    @Override
    public String toString() {
        return "BinaryTreeNode [data=" + data + "]";
    }
}

2. 二叉树类定义:

package com.xxliao.datastructure.tree.binary_tree;

/**
 * @author xxliao
 * @description: 二叉树的实现 以二叉搜索树为例
 * @date 2024/5/28 23:01
 */

public class BinaryTree {
    
    //根节点
    private BinaryTreeNode root;
    //元素个数
    private int size;
    
    //构造方法
    public BinaryTree() {
        root = null;
        size = 0;
    }
    //判断是否为空
    public boolean isEmpty() {
        return root == null;
    }
    //获取根节点
    public BinaryTreeNode getRoot() {
        return root;
    }
}

3. 插入数据

插入数据首先要找到插入的节点,根据“左子节点 < 节点 < 右子节点” 的规律查找插入的位置,当当前节点为空时,该节点就是插入位置,同时我们应该记录当前节点的父节点,然后将当前节点与树关联起来。

/**
    * 添加数据
    * 插入的数据会成为新的叶子节点,然后我们需要遍历查找具体要插入的位置,
    * 以及记录插入位置的父节点,用于利用父节点的leftChildNode或者rightChildNode将新节点关联到书中。
    */
   public boolean add(int data) {
       //添加节点
       BinaryTreeNode newNode = new BinaryTreeNode(data);
       if(root == null) {
           //根节点为空,插入节点直接为root,插入成功
           root = newNode;
           size++;
           return true;
       }else {
           //记录当前节点
           BinaryTreeNode current = root;
           //记录当前节点的父节点
           BinaryTreeNode parent = null;
           //遍历查找
           while(current != null) {
               parent = current;
               if(data < current.data) {
                   //小于当前节点,继续从左子节点查找
                   current = current.leftChildNode;
                   if(current == null) {
                       //当前节点为空,则该为NULL的位置就是新节点要插入的位置
                       parent.leftChildNode = newNode;
                       size++;
                       return true;
                   }
               }else if(data > current.data){
                 //小于当前节点,继续从右子节点查找
                   current = current.rightChildNode;
                   if(current == null) {
                     //当前节点为空,则该为NULL的位置就是新节点要插入的位置
                       parent.rightChildNode = newNode;
                       size++;
                       return true;
                   }
               }else {
                   //该插入数在树中已经存在,暂不考虑
                   System.out.println("Can't add:"+data);
               }
           }
           return false;
       }
   }

4. 删除节点

  • 删除叶子节点
    删除叶子节点我们只需找到该节点,并同时记录删除节点的父节点,然后修改父节点的leftChildNode或者rightChildNode指向为NUlLL就可以成功删除该节点。
    在这里插入图片描述
  • 删除是有一个子节点的节点
    删除只有一个子节点的节点,我们只需要找到该节点,共同使记录删除节点的父节点,然后将父节点的对应的leftChildNode或者rightChildNode修改为指向删除节点唯一子节点即可。
    在这里插入图片描述
  • 删除有两个子节点的节点
    删除节点含有两个子节点的情况下,我们首先要根据树的左右节点的“左子节点 < 当前节点 < 右子节点”特性,找到替代删除节点的节点,然后进行删除操作。具体规则为:
    1. 从删除节点的右子树开始查找,遍历找出右子树最靠左的子孙左子节点,即为替换节点。
    2. 然后将替代节点父节点的左子节点指向替换节点的右子节点。
    3. 替代节点的右子节点指向删除节点的右子节点。
      在这里插入图片描述
//删除数据
 public boolean remove(int data) {
     if(isEmpty()) {
         throw new RuntimeException("Tree is empty,Can't remove!");
     }
     //记录当前节点,就是要删除的节点
     BinaryTreeNode current = root;
     //记录当前节点的父节点
     BinaryTreeNode parent = null;
     //标记删除接单是否是父节点的左子节点
     boolean isLeftChild = false;
     
     //遍历查找要删除的节点current
     while(current.data != data) {
         parent = current;
         if(data< current.data) {
             //小于,继续从左子节点查找
             isLeftChild = true;
             current = current.leftChildNode;
         }else {
             //大于,继续从右子节点查找
             isLeftChild = false;
             current = current.rightChildNode;
         }
         if(current == null) {
             //没有查找到
             return false;
         }
     }
     
     if(current.leftChildNode == null && current.rightChildNode == null) {
         //删除节点为叶子节点
         if(current == root) {
             //删除节点为根节点
             root = null;
         }else if(isLeftChild) {
             //删除节点为父节点的左子节点
             parent.leftChildNode = null;
         }else {
             //删除节点为父节点的右子节点
             parent.rightChildNode = null;
         }
     }else if(current.leftChildNode != null && current.rightChildNode == null) {
         //删除节点只有一个左子节点
         if(current == root) {
             //删除节点为根节点
             root = null;
         }else if(isLeftChild) {
             //删除节点为父节点的左子节点
             parent.leftChildNode = current.leftChildNode;
         }else {
             //删除节点为父节点的右子节点
             parent.rightChildNode = current.leftChildNode;
         }
     }else if(current.leftChildNode == null && current.rightChildNode != null) {
         //删除节点只有一个子节点,右子节点
         if(current == root) {
             //删除节点为根节点
             root = current.rightChildNode;
         }else if(isLeftChild) {
             //删除节点为父节点的左子节点
             parent.leftChildNode = current.rightChildNode;
         }else {
             //删除节点为父节点的右子节点
             parent.rightChildNode = current.rightChildNode;
         }
     }else {
          //删除节点存在两个子节点,找出替代节点
         BinaryTreeNode successor = getSuccessor(current);
         if(current == root) {
             //删除节点是根节点,根节点等于体检节点
             root = successor;
         }else if(isLeftChild) {
             //删除节点是父节点的左子节点
             parent.leftChildNode = successor;
         }else {
             //删除节点是父节点的右子节点
             parent.rightChildNode = successor;
         }
     }
     return true;
 }

 //找出当前节点的替代节点
 private BinaryTreeNode getSuccessor(BinaryTreeNode deleteNode) {
     // 替代节点
     BinaryTreeNode successor = deleteNode;
     // 替代节点的父节
     BinaryTreeNode successorParent = deleteNode;
     // 遍历时的当前节点
     BinaryTreeNode current = deleteNode.rightChildNode;
     //遍历
      while(current != null) {
          //替代节点的父节点向下移动,变成替代节点
          successorParent = successor;
          //替代节点向下移动,变成当前节点
          successor = current;
          //当前节点向左子节点遍历(找出最小值替换)
          current = current.leftChildNode;
      }
      //后继节点不是删除节点的右子节点,将后继节点替换删除节点
      if(successor != deleteNode.rightChildNode){
          successorParent.leftChildNode= successor.rightChildNode;
          successor.rightChildNode = deleteNode.rightChildNode;
      }
      return successor;
 }

5. 遍历树

二叉树的遍历一般有三种方式:前序遍历,中序遍历和后序遍历。而二叉搜索树最常用的是中序遍历(从小到大)。
前序遍历:根节点 --> 左子树 --> 右子树
中序遍历:左子树 --> 根节点 --> 右子树
后序遍历:左子树 --> 右子树 --> 根节点
在这里插入图片描述

//前序遍历
public void preOrder(BinaryTreeNode current){
    if(current != null){
        //根节点
        System.out.print(current.data+" ");
        //左子树遍历
        preOrder(current.leftChildNode);
        //右子树遍历
        preOrder(current.rightChildNode);
    }
}

//中序遍历
public void infixOrder(BinaryTreeNode current){
    if(current != null){
        //左子树遍历
        infixOrder(current.leftChildNode);
        //根节点
        System.out.print(current.data+" ");
        //右子树遍历
        infixOrder(current.rightChildNode);
    }
}

//后序遍历
public void postOrder(BinaryTreeNode current){
    if(current != null){
        //左子树遍历
        postOrder(current.leftChildNode);
        //右子树遍历
        postOrder(current.rightChildNode);
        //根节点
        System.out.print(current.data+" ");
    }
}

6. 测试

package com.xxliao.datastructure.tree.binary_tree;

/**
 * @author xxliao
 * @description: 二叉搜索树 测试客户端
 * @date 2024/5/28 23:22
 */

public class BinaryTreeTestClient {

    public static void main(String[] args) {
        //创建树
        BinaryTree binaryTree = new BinaryTree();
        //数据源,无序的1~10
        int[] array = {4,6,1,3,2,7,8,9,5,10};
        //添加数据
        for (int i = 0; i < array.length; i++) {
            binaryTree.add(array[i]);
        }
        //前序遍历
        System.out.print("前序遍历");
        binaryTree.preOrder(binaryTree.getRoot());
        System.out.println();
        //中序遍历
        System.out.print("中序遍历");
        binaryTree.infixOrder(binaryTree.getRoot());
        System.out.println();
        //后序遍历
        System.out.print("后序遍历");
        binaryTree.postOrder(binaryTree.getRoot());
        System.out.println();
        //删除5
        System.out.println("删除5");
        binaryTree.remove(5);
        //前序遍历
        System.out.print("前序遍历");
        binaryTree.preOrder(binaryTree.getRoot());
        System.out.println();
        //中序遍历
        System.out.print("中序遍历");
        binaryTree.infixOrder(binaryTree.getRoot());
        System.out.println();
        //后序遍历
        System.out.print("后序遍历");
        binaryTree.postOrder(binaryTree.getRoot());
        System.out.println();
    }
}

测试结果:
在这里插入图片描述

完整代码

https://github.com/xxliao100/datastructure_algorithms.git

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

骑车上酒吧

帮到了您,有闲钱,再打赏哦~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值