二叉树之二叉链表

最新推荐文章于 2023-06-03 11:00:15 发布
最新推荐文章于 2023-06-03 11:00:15 发布
阅读量1.6k 收藏 5
点赞数
分类专栏： Java 数据结构 文章标签： java 二叉树 二叉链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011677050/article/details/53414706
版权

本文利用java语言模拟二叉树的二叉链表的实现，下面先对二叉树的相关概念作简单介绍：
二叉树：每个结点至多有两颗子树，且子树有左右之分，其次序不能任意颠倒； 基本形态：空、仅有根结点、左子树为空、右子树为空、左右子树均非空；
完全二叉树父子结点序号关系：
* 如果i=1，则结点i为根结点，否则其双亲结点为[i/2];
* 如果2i > n，则结点i无左孩子，否则其左孩子结点为2i;
* 如果2i+1 > n，则结点i无右孩子，否则右孩子结点为2i+1;
二叉链表：结点包含数据域和左右指针（引用）域的链表；

下面主要给出二叉链表的实现：

1. 二叉链表的结点

package org.sky.tree;

/**
 * 二叉链表结点
 * 
 * @author sky
 *
 * @param <E>
 */
public class BinaryTreeNode<E> {
    E element;
    BinaryTreeNode<E> leftChild;
    BinaryTreeNode<E> rightChild;


    public BinaryTreeNode() {
        super();
        this.element = null;
        this.leftChild = null;
        this.rightChild = null;
    }

    public BinaryTreeNode(E element) {
        super();
        this.element = element;
        this.leftChild = null;
        this.rightChild = null;
    }

    public BinaryTreeNode(E element, BinaryTreeNode<E> leftChild,
            BinaryTreeNode<E> rightChild) {
        super();
        this.element = element;
        this.leftChild = leftChild;
        this.rightChild = rightChild;
    }

    public E getElement() {
        return element;
    }
    public void setElement(E element) {
        this.element = element;
    }
    public BinaryTreeNode<E> getLeftChild() {
        return leftChild;
    }
    public void setLeftChild(BinaryTreeNode<E> leftChild) {
        this.leftChild = leftChild;
    }
    public BinaryTreeNode<E> getRightChild() {
        return rightChild;
    }
    public void setRightChild(BinaryTreeNode<E> rightChild) {
        this.rightChild = rightChild;
    }   

    public boolean isLeaf() {
        if (this.leftChild == null && this.rightChild == null) {
            return true;
        }
        return false;
    }
}

2. 二叉链表实现

package org.sky.tree;

import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * 二叉链表实现
 * 
 * @author sky
 *
 * @param <E>
 */
public class BinaryTree<E> {
    private BinaryTreeNode<E> root;

    public BinaryTree() {
        super();
        this.root = new BinaryTreeNode<E>();
    }

    public boolean isEmpty() {
        if (root == null) {
            return true;
        }
        return false;
    }

    public BinaryTreeNode<E> getRoot() {
        return root;
    }   

    /**
     * 将输入的数据随机分配在二叉树的结点，以生成随机二叉树
     * @param node
     * @param element
     */
    public void createTreeRandomly(BinaryTreeNode<E> node, E element){
        if(root == null){
            root = new BinaryTreeNode<E>();
        }else{
            if(Math.random() > 0.5){
                if(node.leftChild == null){
                    node.leftChild = new BinaryTreeNode<E>(element);
                }else{
                    createTreeRandomly(node.leftChild,element);
                }
            }else{
                if(node.rightChild == null){
                    node.rightChild = new BinaryTreeNode<E>(element);
                }else{
                    createTreeRandomly(node.rightChild,element);
                }
            }
        }
    }

    /**
     * 根据传入的集合创建完全二叉树
     * 此处利用了完全二叉树父结点和子结点间的关系：如果i=1，则结点i为根结点，否则其双亲结点为[i/2];
     *                              如果2i > n，则结点i无左孩子，否则其左孩子结点为2i;
     *                              如果2i+1 > n，则结点i无右孩子，否则右孩子结点为2i+1;
     * @param c
     */
    private BinaryTreeNode<E> node = null;
    public void createCompleteBinaryTree(Collection<? extends E> c){
        if(c != null && c.size() > 0){
            List<BinaryTreeNode<E>> treeList = new LinkedList<BinaryTreeNode<E>>();
            for(Object o : c){              
                BinaryTreeNode<E> binaryTreeNode = new BinaryTreeNode<E>((E)o);
                treeList.add(binaryTreeNode);
            }

            LinkedBlockingDeque<BinaryTreeNode<E>> queue = new LinkedBlockingDeque<BinaryTreeNode<E>>();
            //对前treeList.size()/2 - 1个父节点按照父节点与孩子节点的数字关系建立二叉树 
            for(int parentIndex =  0; parentIndex < treeList.size()/2; parentIndex++){              
                if(parentIndex == 0){
                    root = treeList.get(parentIndex);
                    //左子树
                    root.leftChild = treeList.get(parentIndex*2 + 1);
                    queue.add(root.leftChild);
                    //右子树
                    root.rightChild = treeList.get(parentIndex*2 +2);
                    queue.add(root.rightChild);
                }else{
                    if(!queue.isEmpty() && parentIndex*2+1 < treeList.size()){
                        node = (BinaryTreeNode<E>) queue.poll();
                        if(parentIndex*2+1 < treeList.size()){
                            //左子树
                            node.leftChild = treeList.get(parentIndex*2 + 1);
                            queue.add(node.leftChild);
                        }
                        if(parentIndex*2+2 < treeList.size()){
                            //右子树
                            node.rightChild = treeList.get(parentIndex*2 + 2);
                            queue.add(node.rightChild);
                        }
                    }else{
                        return ;
                    };
                }
            }           
        }
    }

    /**
     * 先序遍历创建二叉树，其中输入的‘#’代表空结点;
     * 例如输入input.txt:- + a # # * # # / e # # f # #;
     * @param inputFile
     */
    public void preOrderCreateBinaryTree(String inputFile){
        Scanner scanner = null;
        try{
            scanner = new Scanner(inputFile);
        }catch(Exception  e){
            e.printStackTrace();
        }
        this.root = preOrderCreateBinaryTree(root, scanner);
    }   
    public BinaryTreeNode<E> preOrderCreateBinaryTree(BinaryTreeNode<E> node, Scanner scanner){
        String temp = scanner.next();
        if(temp.trim().equals("#")){
            return null;
        }else{
            node = new BinaryTreeNode<E>((E)temp);
            node.setLeftChild(preOrderCreateBinaryTree(node.getLeftChild(), scanner));
            node.setRightChild(preOrderCreateBinaryTree(node.getRightChild(), scanner));
            return node;
        }
    }

    /**
     * 递推：知道第一个，推出下一个，直到达到目的。
     * 递归：要知道第一个，需要先知道下一个，直到一个已知的，再反回来，得到上一个，直到第一个。
     */

    /**
     * 递归求二叉树结点个数
     * @param root
     * @return 二叉树结点个数
     */
    public int getNodeNumber(BinaryTreeNode<E> root){
        if(root == null){
            return 0;
        }else{
            return getNodeNumber(root.leftChild) + getNodeNumber(root.rightChild) + 1;
        }
    }

    /**
     * 递归求二叉树的深度
     * @param root
     * @return 二叉树的深度
     */
    public int getDepth(BinaryTreeNode<E> root){
        if(root == null){
            return 0;
        }else{
            int depthLeft = getDepth(root.leftChild);   //左子树深度
            int depthRight = getDepth(root.rightChild); //右子树深度
            return depthLeft > depthRight ? (depthLeft+1) : (depthRight+1);
        }
    }

    /**
     * 递归求二叉树第k层的结点个数
     * @param root
     * @param k
     * @return 第k层的结点个数
     */
    public int getKthLevelNodeNumber(BinaryTreeNode<E> root, int k){
        if(root == null || k < 1){
            return 0;
        }
        if(k == 1){
            return 1;
        }
        int leftNumber = getKthLevelNodeNumber(root.leftChild, k-1);
        int rightNumber = getKthLevelNodeNumber(root.rightChild,k-1);
        return (leftNumber + rightNumber);
    }

    /**
     * 递归求二叉树的叶子结点数
     * @param root
     * @return
     */
    public int getLeafNodeNumber(BinaryTreeNode<E> root){
        if(root == null){
            return 0;
        }
        if(root.leftChild == null && root.rightChild == null){
            return 1;
        }
        int leftNumber = getLeafNodeNumber(root.leftChild);
        int rightNumber = getLeafNodeNumber(root.rightChild);
        return (leftNumber + rightNumber);
    }

    /**
     * 判定两个二叉树结构是否相同
     * 递归解法：
     * （1）如果两棵二叉树都为空，返回真
     * （2）如果两棵二叉树一棵为空，另一棵不为空，返回假
     * （3）如果两棵二叉树都不为空，如果对应的左子树和右子树都同构返回真，其他返回假
     * @param root1
     * @param root2
     * @return 结构相同时，返回true;
     */
    public boolean strutureComp(BinaryTreeNode<E> root1, BinaryTreeNode<E> root2){
        if(root1 == null && root2 == null){
            return true;
        }else if(root1 == null || root2 == null){
            return false;
        }
        boolean leftResult = strutureComp(root1.leftChild, root2.leftChild);
        boolean rightResult = strutureComp(root1.rightChild, root2.rightChild);
        return (leftResult && rightResult);
    }

    /**
     * 递归插入结点
     * @param root
     * @param element
     * @return 二叉树
     */
    public BinaryTreeNode<E> insert(BinaryTreeNode<E> root, E element){
        BinaryTreeNode<E> pointer = new BinaryTreeNode<E>(element);
        if(root == null){
            root = pointer;
        }else if(root.leftChild == null){
            root.leftChild = insert(root.leftChild, element);
        }else if(root.rightChild == null){
            root.rightChild = insert(root.rightChild, element);
        }
        return root;
    }

    /**
     * 求二叉树中特定子结点的父结点
     * @param root
     * @param childNode
     * @return 存在父结点时，返回父结点；否则，返回null
     */
    public BinaryTreeNode<E> getParent(BinaryTreeNode<E> root, BinaryTreeNode<E> childNode){
        if(root == null){
            return null;
        }
        if(root.leftChild == childNode || root.rightChild == childNode){
            return root;
        }
        if(getParent(root.leftChild, childNode) != null){
            return getParent(root.leftChild, childNode);
        }else{
            return getParent(root.rightChild, childNode);
        }
    }

    /**
     * 递归删除二叉树，释放相应的存储空间
     * @param root
     */
    public void destoryBinaryTree(BinaryTreeNode<E> root){
        if(root != null){
            destoryBinaryTree(root.leftChild);
            destoryBinaryTree(root.rightChild);
            root = null;
        }
    }

    /**
     * 层序遍历（广度优先遍历）
     * @param root
     */
    public void levelOrder(BinaryTreeNode<E> root){
        Queue<BinaryTreeNode<E>> queue = new LinkedBlockingQueue<BinaryTreeNode<E>>();
        BinaryTreeNode<E> pointer = root;
        /**
         * 当前结点非空时，放入队首
         */
        if(pointer != null){
            queue.add(pointer);
        }

         /*
         * 队列不为空时，先访问中间节点，访问完成后弹出队首节点；然后是左节点，再是右节点；
         */
        while(!queue.isEmpty()){
            pointer = queue.peek();   
            visit(pointer);
            queue.remove();
            if(pointer.leftChild != null){
                queue.add(pointer);
            }
            if(pointer.rightChild != null){
                queue.add(pointer);
            }

        }
    }

    /**
     * 递归先序遍历二叉树
     * @param root
     */
    public void preOrder(BinaryTreeNode<E> root){
        if (root == null){
            return;
        }              
        visit(root);
        preOrder(root.leftChild);
        preOrder(root.rightChild);
    }

    /**
     * 非递归先序遍历二叉树
     * @param root
     */
    public void nPreOrder(BinaryTreeNode<E> root){
        Stack<BinaryTreeNode<E>> stack = new Stack<BinaryTreeNode<E>>();
        BinaryTreeNode<E> pointer = root;
        while(!stack.isEmpty() || pointer != null){
            if(pointer != null){
                visit(pointer);
                if(pointer.rightChild != null){
                    stack.push(pointer.rightChild);
                }
                pointer = pointer.leftChild;
            }else{
                pointer = stack.pop();
            }
        }
    }

    /**
     * 递归中序遍历
     * @param root
     */
    public void inOrder(BinaryTreeNode<E> root){
        if (root == null){
            return;
        }   
        inOrder(root.leftChild);
        visit(root);
        inOrder(root.rightChild);
    }

    /**
     * 非递归中序遍历1
     * @param root
     */
    public void nInOrder(BinaryTreeNode<E> root){
        Stack<BinaryTreeNode<E>> stack = new Stack<BinaryTreeNode<E>>();
        BinaryTreeNode<E> pointer = root;
        while(pointer != null || !stack.isEmpty()){
            if(pointer != null){
                stack.push(pointer);
                pointer = pointer.leftChild;
            }else{
                pointer = stack.pop();
                visit(pointer);
                pointer = pointer.rightChild;               
            }
        }
    }

    /**
     * 非递归中序遍历2
     * @param root
     */
    public void nInOrders(BinaryTreeNode<E> root){
        Stack<BinaryTreeNode<E>> stack = new Stack<BinaryTreeNode<E>>();
        BinaryTreeNode<E> pointer = root;
        stack.push(pointer);
        while(!stack.isEmpty()){
            while(pointer != null){
                stack.push(pointer.leftChild);
                pointer = pointer.leftChild;
            }
            stack.pop();
            if(!stack.isEmpty()){
                pointer = stack.pop();
                visit(pointer);
                pointer = pointer.rightChild;
                stack.push(pointer);
            }
        }
    }

    /**
     * 递归后序遍历
     * @param root
     */
    public void postOrder(BinaryTreeNode<E> root){
        if (root == null){
            return;
        }   
        postOrder(root.leftChild);
        postOrder(root.rightChild);
        visit(root);
    }

    /**
     * 非递归后序遍历
     * @param root
     */
    public void nPostOrder(BinaryTreeNode<E> root){
        Stack<BinaryTreeNode<E>> stack = new Stack<BinaryTreeNode<E>>(); //初始化栈，用于保存带访问的节点
        BinaryTreeNode<E> pointer = root;                                //保存根节点
        BinaryTreeNode<E> preNode = root;                                //保存前一个被访问的节点
        while(!stack.isEmpty() || pointer != null){
            //若当前节点不空，就一直进栈，然后继续向左走
            while(pointer.leftChild != null){
                stack.push(pointer);
                pointer = pointer.leftChild;
            }
             /*
             * 当前节点为空时，分两种情况：
             * 1、当前节点移动到栈顶处，然后访问栈顶元素的右节点
             * 2、当前节点移动到栈顶，但是栈顶元素没有右节点，这就需要弹出栈顶元素，再对此元素访问；
             * 然后再对新的栈顶元素进行判断即可
             */
            while((pointer != null && pointer.rightChild == null) || pointer.rightChild == preNode){
                visit(pointer);
                preNode = pointer;
                if(stack.isEmpty()){
                    return;
                }
                pointer = stack.pop();
            }
            stack.push(pointer);
            pointer = pointer.rightChild;
        }
    }

    /**
     * 访问当前结点
     * @param current
     */
    public void visit(BinaryTreeNode<E> current){
        if(current != null && current.element != null){
            System.out.println(current.element);
        }else{
            System.out.println("null");
        }
    }
}

3. 参考文献

1. java创建二叉树并递归遍历二叉树
2. java实现二叉树相关代码—–数据结构
3. Java实现二叉树的创建、递归/非递归遍历
4. Java实现二叉树的创建和遍历操作（有更新）

deepblueskys
关注
专栏目录
数据结构-二叉链表的结构与实现
m0_61789994的博客
05-11 8464
二叉链表是一种特殊的链表，它的每个节点都有两个指针，一个指向左子树，一个指向右子树。这种结构可以用来表示树形结构，如二叉树等。二叉链表是一种常用的数据结构，它可以用于实现二叉树、哈夫曼树、二叉堆、二叉搜索树等算法。二叉链表的结构相对简单，实现起来也比较容易，但是需要注意指针的使用，避免出现空指针和死循环等问题。在实际应用中，我们需要根据具体的需求选择合适的数据结构，以提高算法的效率和性能。
【二叉树的链式结构（二叉链）及实现】
weixin_56235740的博客
01-03 816
链式二叉树（二叉链）的实现与应用
根据父子关系建立二叉树
下午茶
04-24 2817
根据父子关系建立二叉树
链表实现 二叉树
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
08-30 2166
链表实现二叉树
链表实现二叉树
qq_73881574的博客
04-06 1311
如果子树为空 返回0 不为空返回1。执行逻辑：判断左右子树中高度大的那颗，在此基础上加上自身返回上一级。执行逻辑：统计左右子树叶子的个数 加上自身 返回上一级。将一层的节点全部遍历完了以后再遍历下一层。递归的算法：当根为NULL时，开始返回。执行逻辑：将NULL也push进队列。返回条件：子树为空 或者找到目标值。执行逻辑：即找k-1层子树的个数。返回条件：走到目标层（k==1）执行逻辑：先寻找所有的左子树。是层层返回的 而不是一下返回。出谁，将谁的子树全部带入。返回条件： 为空返回0。
头歌数据结构二叉树的二叉链表存储及基本操作
05-18
首先，二叉链表存储的二叉树是一种通过链表结构来表示二叉树的方式。每个结点包含一个数据元素、一个指向左子结点的指针和一个指向右子结点的指针。在C语言中，可以定义一个结构体类型`BiTNode`来表示这样的结点： ...
二叉树的二叉链表源码
11-17
二叉树的二叉链表源码
二叉树的二叉链表存储表示
06-13
"二叉树的二叉链表存储表示" 在计算机科学中，二叉树是一种重要的数据结构，它广泛应用于许多领域，如数据库、操作系统、编译器等。二叉树的存储表示是指将二叉树存储在计算机中的一种方式，其中二叉链表存储表示是...
erchashu.rar_二叉树 二叉链表
09-19
二叉树和二叉链表是数据结构领域中的重要概念，它们在计算机科学中有着广泛的应用，例如在文件系统、编译器设计、图形处理等领域。在这个“erchashu.rar”压缩包中，我们主要探讨如何将一个给定的二叉树转化为二叉...
基于链表实现二叉树(java算法源码)
01-20
/* * 基于链表实现二叉树 */ package dsa; public class BinTree_LinkedList implements BinTree { protected BinTreePosition root;//根节点 /**************************** 构造函数 ****************************/ public BinTree_LinkedList() { this(null); } public BinTree_LinkedList(BinTreePosition r) { root = r; } /**************************** BinaryTree接口方法 ****************************/ //返回树根 public BinTreePosition getRoot() { return root; } //判断是否树空 public boolean isEmpty() { return null == root; } //返回树的规模（即树根的后代数目） public int getSize() { return isEmpty() ? 0 : root.getSize(); } //返回树（根）的高度 public int getHeight() {return isEmpty() ? -1 : root.getHeight(); } //前序遍历 public Iterator elementsPreorder() { return root.elementsPreorder(); } //中序遍历 public Iterator elementsInorder() { return root.elementsInorder(); } //后序遍历 public Iterator elementsPostorder() { return root.elementsPostorder(); } //层次遍历 public Iterator elementsLevelorder() { return root.elementsLevelorder(); } }
二叉树的二叉链表表示与基本操作
热门推荐
秋之颂的博客
03-18 1万+
关于二叉树的二叉链表表示与基本操作！ 含伪代码！ 附源码！
二叉链表存储二叉树
weixin_34032792的博客
08-20 4566
链式存储结构 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。其结点结构为： 其中，data域存放某结点的数据信息；lchild与rchild分别存放指向左孩子和右孩子的指针，当左孩子或右孩子不存在时，相应指针域值为空（用...
数据结构：二叉树的链式结构
最新发布
Yikefore的博客
06-03 5809
链式二叉树创建非常详细的过程：包含如何前序遍历创建二叉树、对二叉树的前、中、后序遍历、二叉树节点个数、二叉树叶子节点个数、二叉树的高度、第k层节点个数、查找节点、层序遍历、判断二叉树是否为完全二叉树、二叉树的销毁.....附带完整代码以及图解
深入理解数据结构之树
上善若泪
07-05 4013
文章目录1 前言1.1 结点概念1.2 树结点声明2 树2.1 树的定义 1 前言 树是数据结构中的重中之重，尤其以各类二叉树为学习的难点。一直以来，对于树的掌握都是模棱两可的状态，现在希望通过写一个关于二叉树的专题系列。在学习与总结的同时更加深入的了解掌握二叉树。本系列文章将着重介绍一般二叉树、完全二叉树、满二叉树、线索二叉树、霍夫曼树、二叉排序树、平衡二叉树、红黑树 1.1 结点概念 结点是数据结构中的基础，是构成复杂数据结构的基本组成单位 1.2 树结点声明 本系列文章中提及的结点专指树的结点。例如：
二叉树的二叉链表的简单实现及操作
TECH_PRO的博客
06-05 5354
本文主要简单的说一说二叉树的二叉链表的简单实现及操作。简单的说一说二叉链表的结点定义，树的创建，结点的插入，子树的销毁、树的拷贝等常用操作。 一、创建二叉树、拷贝二叉树 本文创建的二叉树采用二叉链表的形式来创建，二叉链表定义的树的结点通常包含一个数据域，两个地址域（分别用来指向左右子树），所以在创建树之前需要定义一个表示结点的结构体，具体实现如下： /* 定义一个结构体用于表示二叉树
树：二叉链表的实现
重庆李四
02-12 7328
二叉链表介绍二叉树每个结点最多有2个孩子，所以为它设计一个数据域和2个指针域是比较自然的想法，我们称这样的链表叫做二叉链表。二叉链表思路二叉链表的数据结构，数据域，左右孩子指针域。每个树结点都有左右孩子，如果没有孩子那么孩子指针域为NULL。我们用char类型的数据来模拟二叉链表的创建和遍历。我们知道二叉链表的遍历有3种，前序遍历，中序遍历，后序遍历。那么创建链表的时候同样我们可以约定是前序、中序...
数据结构学习笔记（C++）：二叉链表的创建与实现
有朋自远方来，不亦乐乎。
10-19 3687
涉及二叉链表的构造、析构、四种遍历方式的详细代码及注释。 代码中对于Create函数不易理解的地方已用图片的形式表现： 这道小题可以看完代码并理解后在来做。 //二叉链表的创建与实现 #include<iostream> using namespace std; struct BiNode//创建树的结点 { int data;//数据域 BiNode *leftChild;//左孩子指针 BiNode* rightChild;//右孩子指针 }; class ...
练习12——二叉树与表达式
Scrutiny的博客
03-25 514
将通过二叉链表实现的表达式二叉树进行输出，同时计算出结果。 要求： 1）二叉树建立时，使用先序建立； 2）四个运算符包括：+, -, *, /; 3 ) 在输出时，遇到优先级问题时，相应的括号也要输出。 提示： 1）递归执行下列步骤即可求值：先分别求出左子树和右子树表示的子表达式的值，最后根据根结点的运算符的要求，计算出表达式的最后结果。 2）二叉树的中序遍历序列与原算术表达式基本相...
Java实现二叉树的二叉链表结构及其构建
本文主要探讨的是二叉树的二叉链表在Java语言中的实现。首先，我们回顾一下二叉树的基本概念。二叉树是一种特殊的树形数据结构，其中每个节点最多有两个子节点，且通常分为左子节点和右子节点，子节点的顺序是有特定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值