二叉树

最新推荐文章于 2022-05-01 12:47:37 发布
最新推荐文章于 2022-05-01 12:47:37 发布
阅读量238 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树

二叉树

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

public class BinaryTree<E extends Comparable<E>> extends AbstractTree<E> {
    private TreeNode<E> root = null;
    private int size = 0;

    @Override
    public boolean search(E e) {
        // TODO Auto-generated method stub
        TreeNode<E> current = root;
        while(current != null) {
            if(e.compareTo(current.item) < 0) {
                current = current.left;
            }
            else if(e.compareTo(current.item) > 0) {
                current = current.right;
            }
            else {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean delete(E e) {
        // TODO Auto-generated method stub
        TreeNode<E> current = root;
        while(current != null) {
            if(e.compareTo(current.item) < 0) {
                current = current.left;
            }
            else if(e.compareTo(current.item) > 0) {
                current = current.right;
            }
            else {
                break;
            }
        }
        if(current == null) {
            return false;
        }
        if(current.left == null) {
            if(current.parent == null) {
                root = current.right;
                current.right.parent = null;
            }
            else {
                if(e.compareTo(current.parent.item) < 0) {
                    current.parent.left = current.right;
                    if(current.right != null) {  //必须要这个判断,否则java.lang.NullPointerException
                        current.right.parent = current.parent.left;
                    }
                    //help GC
                    current.parent = null;
                    current.right = null;
                    current = null;
                }
                else {
                    current.parent.right = current.right;
                    if(current.right != null) {  //必须要这个判断,否则java.lang.NullPointerException
                        current.right.parent = current.parent.right;
                    }
                    //help GC
                    current.parent = null;
                    current.right = null;
                    current = null;
                }
            }
        }
        else {
            TreeNode<E> rm = current.left;
            while(rm.right != null) {
                rm = rm.right;
            }
            current.item = rm.item;
            if(rm.parent.right == rm) {
                rm.parent.right = rm.left;
                if(rm.left != null) {  //必须要这个判断,否则java.lang.NullPointerException
                    rm.left.parent = rm.parent;
                }
                //help GC
                rm.item = null;
                rm.left = null;
                rm = null;
            }
            else {
                current.left = rm.left;
                if(rm.left != null) {  //必须要这个判断,否则java.lang.NullPointerException
                    rm.left.parent = current;
                }
                //help GC
                rm.item = null;
                rm.left = null;
                rm = null;
            }
        }
        size--;
        return true;
    }

    @Override
    public boolean insert(E e) {
        // TODO Auto-generated method stub
        if(root == null) {
            root = new TreeNode<E>(e);
            size++;
        }
        else {
            TreeNode<E> parent = null;
            TreeNode<E> current = root;
            while(current != null) {
                if(e.compareTo(current.item) < 0) {
                    parent = current;
                    current = current.left;
                }
                else if(e.compareTo(current.item) > 0) {
                    parent = current;
                    current = current.right;
                }
                else {
                    return false;
                }
            }
            if(e.compareTo(parent.item) < 0) {
                parent.left = new TreeNode<E>(e);
                parent.left.parent = parent;
            }
            else {
                parent.right = new TreeNode<E>(e);
                parent.right.parent = parent;
            }
            size++;
        }
        return true;
    }

    @Override
    public void inorder() {
        // TODO Auto-generated method stub
        inorder(root);
    }
    private void inorder(TreeNode<E> root) {
        if(root == null) {
            return ;
        }
        inorder(root.left);
        System.out.print(root.item + " ");
        inorder(root.right);
    }

    @Override
    public void nrinorder() {
        // TODO Auto-generated method stub
        Stack<TreeNode<E>> stack = new Stack<>();
        TreeNode<E> c = root;
        while(!stack.isEmpty() || c!=null) {
            while(c != null) {
                stack.push(c);
                c = c.left;
            }
            c = stack.pop();
            System.out.print(c.item + " ");
            c = c.right;
        }
    }

    @Override
    public void preorder() {
        // TODO Auto-generated method stub
        preorder(root);
    }
    private void preorder(TreeNode<E> root) {
        // TODO Auto-generated method stub
        if(root == null) {
            return;
        }
        System.out.print(root.item + " ");
        preorder(root.left);
        preorder(root.right);
    }

    @Override
    public void nrpreorder() {
        // TODO Auto-generated method stub
        TreeNode<E> current = root;
        Stack<TreeNode<E>> stack = new Stack<>();
        while(!stack.isEmpty() || current!=null) {
            if(current == null) {
                current = stack.pop();
            }
            System.out.print(current.item + " ");
            if(current.right != null) {
                stack.push(current.right);
            }
            current = current.left;
        }
    }

    @Override
    public void postorder() {
        // TODO Auto-generated method stub
        postorder(root);
    }
    private void postorder(TreeNode<E> root) {
        if(root == null) {
            return;
        }
        postorder(root.left);
        postorder(root.right);
        System.out.print(root.item + " ");
    }

    @Override
    public void nrpostorder() {
        // TODO Auto-generated method stub
        TreeNode<E> last = null;
        TreeNode<E> current = root;
        Stack<TreeNode<E>> stack = new Stack<>();
        while(!stack.isEmpty() || current!=null) {
            while(current != null) {
                stack.push(current);
                current = current.left;
            }
            current = stack.peek();
            if(current.right==null || current.right==last) {
                System.out.print(current.item + " ");
                last = stack.pop();
                current = null;
            }
            else {
                current = current.right;
            }
        }
    }

    @Override
    public void breadthorder() {
        // TODO Auto-generated method stub
        LinkedList<TreeNode<E>> list = new LinkedList<>();
        TreeNode<E> current = root;
        list.add(current);
        int index = 0;
        while(index < getSize()) {
            for(int i=0;i<list.size();i++) {
                if(list.get(i) != null) {
                    TreeNode<E> temp = list.get(i);
                    System.out.print(temp.item + " ");
                    list.add(i, temp.left);
                    list.add(i+1,temp.right);
                    list.remove(temp);
                    index++;
                    i++;
                }
            }
        }
    }

    @Override
    public int getSize() {
        // TODO Auto-generated method stub
        return size;
    }


    @Override
    public void clear() {
        // TODO Auto-generated method stub
        clearPreorder(root);
        size = 0;
    }
    private void clearPreorder(TreeNode<E> root) {
        root.parent = null;
        root.item = null;
        clearPreorder(root.left);
        clearPreorder(root.right);
    }

    //获得指定元素的路径,如果二叉树中不存在此元素,则返回null
    public ArrayList<TreeNode<E>> path(E e) {
        if(!search(e)) {
            return null;
        }
        ArrayList<TreeNode<E>> list = new ArrayList<>();
        TreeNode<E> current = root;
        while(current != null) {
            list.add(current);
            if(e.compareTo(current.item) < 0) {
                current = current.left;
            }
            else if(e.compareTo(current.item) > 0) {
                current = current.right;
            }
            else {
                break;
            }
        }
        return list;
    }

    //返回二叉树的高度
    public int height() {
        int len = 0;
        ArrayList<TreeNode<E>> list = new ArrayList<>();
        TreeNode<E> current = root;
        list.add(current);
        int index = 0;
        while(index < getSize()) {
            for(int i=0;i<list.size();i++) {
                if(list.get(i) != null) {
                    TreeNode<E> temp = list.get(i);
                    list.add(i, temp.left);
                    list.add(i+1, temp.right);
                    list.remove(temp);
                    index++;
                    i++;
                }
            }
            len++;
        }
        return len;
    }

    //如果此二叉树为完全二叉树,则返回true
    public boolean isFullBinaryTree() {
        ArrayList<TreeNode<E>> list = new ArrayList<>();
        TreeNode<E> current = root;
        list.add(current);
        int index = 0;
        while(index < getSize()) {
            for(int i=0;i<list.size();i++) {
                if(list.get(i) != null) {
                    TreeNode<E> temp = list.get(i);
                    list.add(i,temp.left);
                    list.add(i+1,temp.right);
                    list.remove(temp);
                    index++;
                    i++;
                }
                else {
                    return false;
                }
            }
        }
        return true;
    }

    //返回根节点
    public TreeNode<E> getRoot() {
        return root;
    }

    //返回指定元素的父节点
    public TreeNode<E> getParent(E e) {
        TreeNode<E> current = root;
        while(current != null) {
            if(e.compareTo(current.item) < 0) {
                current = current.left;
            }
            else if(e.compareTo(current.item) > 0) {
                current = current.right;
            }
            else {
                return current.parent;
            }
        }
        return null;
    }

    //返回叶子节点的个数
    public int getNumberOfLeaves() {
        return getNumberOfLeaves(root);
    }
    private int getNumberOfLeaves(TreeNode<E> root) {
        if(root == null) {
            return 0;
        }
        else if(root.right==null && root.left==null) {
            return 1;
        }
        else {
            return getNumberOfLeaves(root.left) + getNumberOfLeaves(root.right);
        }
    }

    //返回非叶子节点的个数
    public int getNumberOfNonLeaves() {
        return getSize()-getNumberOfLeaves();
    }

    static class TreeNode<E extends Comparable<E>> {
        protected E item;
        protected TreeNode<E> parent;
        protected TreeNode<E> left;
        protected TreeNode<E> right;

        public TreeNode(E item) {
            this.item = item;
        }
    }

}
Dnoino
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
二叉树详解
weixin_59371851的博客
07-09 5万+
目录前言一、树的概念和结构1、树的概念2、树的表示 3、树在实际中的应用（表示文件系统的目录树结构）二、二叉树概念及结构1.概念 2、特殊的二叉树3、二叉树的性质4、二叉树的存储4.1顺序存储4.2链状存储 三、二叉树的顺序结构和实现1、二叉树的顺序结构2、堆的概念及结构3、堆的实现3.1堆的代码框架3.2堆的插入3.3堆的删除3.4堆的建立 3.5建堆的时间复杂度 4、堆的应用4.1堆排序 4.2TOP-K问题四、二叉树链式结构的实现 1、建二叉树2、二叉树的遍历2.1前序、中序以及后序遍历2.2层序遍历
python二叉树
惊鸿的博客
03-12 5631
二叉树特征定义 特征 树是一种 非线性的数据结构，，直观的看，他是数据元素（在树中称为结点）按分支关系组织起来的结构，很像自然界中的树那样，树结构在客观世界中广泛存在，如人类社会的族谱和各种社会组织机构都可以用树形象来表示。还有比如在编译程序的时候，它可以用来表示源程序的语法结构，又或者在数据库中，树型结构也是信息的重要组织形式之一。 总之：一切具有层次关系的问题都可以用树来描述。 定义 树（Tree）是n（≥0）个节点的有限集。在任意一棵树中： 1、有且仅有一个称为根（Root）的结点 2、当n&g
【数据结构】——二叉树详解
atwdy的博客
07-28 5万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
二叉树的基本操作
Daioo 随笔
04-21 12万+
一、实验目的 1、掌握二叉树的定义； 2、掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度计算等。 二、实验内容 （一）用递归的方法实现以下算法： 1、以二叉链表表示二叉树，建立一棵二叉树（算法5.3）； 2、输出二叉树的中序遍历结果（算法5.1）； 3、输出二叉树的前序遍历结果（见讲稿）； 4、输出二叉树的后序遍历结果（见讲稿）； 5、计算二叉树的深度（算法5.
平衡二叉树
清风
05-01 4万+
1.定义 平衡二叉树，又称AVL树，用于解决二叉排序树高度不确定的情况，如果二叉排序树的子树间的高度相差太大，就会让二叉排序树操作的时间复杂度升级为O(n)，为了避免这一情况，为最坏的情况做准备，就出现了平衡二叉树，使树的高度尽可能的小，其本质还是一棵二叉搜索树。 平衡二叉树的性质： 左子树和右子树的高度之差的绝对值小于等于1 左子树和右子树也是平衡二叉树 为了方便起见，给树上的每个结点附加一个数字，给出该结点左子树与右子树的高度差，这个数字称为结点的平衡因子（BF） 平衡因子=结点左子树的高度-
树、森林与二叉树的转换
热门推荐
CSDN
12-30 14万+
树、森林与二叉树的转换 1、树转换为二叉树 由于二叉树是有序的，为了避免混淆，对于无序树，我们约定树中的每个结点的孩子结点按从左到右的顺序进行编号。 将树转换成二叉树的步骤是： （1）加线。就是在所有兄弟结点之间加一条连线； （2）抹线。就是对树中的每个结点，只保留他与第一个孩子结点之间的连线，删除它与其它孩子结点之间的连线； （3）旋转。就是以树的根结点为轴心，将整棵树顺时针旋转一定...
二叉树建立
Monster
03-20 3万+
结束二叉树输入：如何结束创建二叉树的输入那；把二叉树补全 前序（输入）：AB##C## 中序：#B#A#C# 后序：##B##CA 输出结果如下： 代码如下 #include<iostream> using namespace std; //定义节点 typedef struct node { struct node *left; struct node *...
二叉树各种类型汇总
上善若泪
06-26 8605
文章目录1 树类型1.1 二叉树1.2 完全二叉树1.3 满二叉树1.4 二叉搜索树（二叉排序树、二叉查找树）1.5 平衡二叉树1.6 红黑树1.6.1 红黑树概念1.6.2 红黑树和AVL树区别1.7 B树类型1.7.1 B树1.7.2 B-树1.7.3 B+树1.7.4 B*树 学习了树的结构类型后，主要对各种树类型进行汇总总结 1 树类型 树中的基本概念：https://jingzh.blog.csdn.net/article/details/107128291 树类型概述： 二叉树，完全二叉树，满二
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
二叉树 基础
03-08
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
线索二叉树
04-10
通过前序序列创建线索二叉树 1:中序遍历 2:查找节点前驱后继 3:插入节点 4:删除节点 0:退出
二叉树建立遍历
01-03
二叉树是一种重要的数据结构，它由节点组成，每个节点有两个子节点，分别称为左子节点和右子节点。在计算机科学中，二叉树被广泛应用于搜索、排序、表达式解析等多种场景。本主题主要关注的是二叉树的建立以及它的...
二叉树代码
04-29
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
二叉树深度_二叉树查询_二叉树深度_
10-01
二叉树是一种在计算机科学中广泛应用的数据结构，它由节点（也称为结点）组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的深度是指从根节点到最远叶节点的最长路径上边的数目，即树的最大层数...
二叉树操作算法详解
"二叉树相关的C语言实现代码，包括初始化、创建、遍历等基本操作" 二叉树是一种在计算机科学中广泛使用的数据结构，它由节点（或称为结点）组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值