数据结构 JAVA描述（四） 树与二叉树基础

最新推荐文章于 2021-03-21 08:30:55 发布
最新推荐文章于 2021-03-21 08:30:55 发布
阅读量858 收藏
点赞数 2
分类专栏： 数据结构 文章标签： java 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuquan0071/article/details/50430068
版权

基础理论

树的定义：

树是由n（n≥0）个结点所构成的有限集合，当n=0时，称为空树；当n>0时，满足以下条件：

  1. 有且仅有一个称为根的结点
  2. 其余结点可分为m个互不相交的有限集合

二叉树概念：

1.二叉树与树的不同：

  • 树中每个结点可以有多棵子树，而二叉树每个结点最多有两个子树
  • 树中子树不分顺序，而二叉树的子树有严格的左、右之分
  • 度小于2时，二叉树可以只有右子树而没有左子树，而在树中一个结点若没有第一棵子树则不可能有第二棵子树的存在

2.满二叉树：

  • 所有结点要么是叶结点，要么左右子树都不为空，且所有叶结点都在同一层上。

3.完全二叉树：

  • 在一颗n个结点的二叉树中，它的逻辑结构与满二叉树的前n个结点的逻辑结构相同，则称这样的二叉树为完全二叉树。

4.单分支树的定义

二叉树的性质：

  1. 二叉树中第i（i≥0）层的结点数最多为2ⁿ
  2. 深度为n（n≥1）的二叉树中最多有2ⁿ-1的结点
  3. 叶结点个数为n0，度为2的结点个数为n2，则有n0 = n2 +1
  4. 具有n个结点的完全二叉树，深度为⌊log₂n⌋+1
  5. 完全二叉树根结点从0开始自上向下、自左向右进行编号，则对于任意i（0≤i≤n）
    • 若i>0，则双亲编号是⌊（i-1）/2⌋
    • 若2i+1≥n，则无左孩子，否则左孩子编号就是2i+1
    • 若2i+2≥n，则无右孩子，否则右孩子编号就是2i+2

二叉树的存储结构：

1.顺序存储

2.链式存储

  • 二叉链式存储结构：左孩子，右孩子
  • 三叉链式存储结构：左孩子，右孩子，双亲

二叉链式存储结构下的二叉树的描述

BiTreeNode： 

package BiTree;

import Queue.LinkQueue;
import Stack.LinkStack;

/**
 * @Description 二叉树的存储结点 
 * 
 * @time 2015年12月2日 下午11:20:38
 */
class BiTreeNode {
    private Object data;
    private BiTreeNode lchild, rchild;

    public BiTreeNode() {
        this(null);
    }

    public BiTreeNode(Object data) {
        this(data, null, null);
    }

    public BiTreeNode(Object data, BiTreeNode lchild, BiTreeNode rchild) {
        this.data = data;
        this.lchild = lchild;
        this.rchild = rchild;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public BiTreeNode getLchild() {
        return lchild;
    }

    public void setLchild(BiTreeNode lchild) {
        this.lchild = lchild;
    }

    public BiTreeNode getRchild() {
        return rchild;
    }

    public void setRchild(BiTreeNode rchild) {
        this.rchild = rchild;
    }
}

BiTree：

/**
 * @Description 链式二叉树结构，相关操作 
 * @time 2015年12月2日 下午11:20:26
 */
public class BiTree {
    private BiTreeNode root;

    public BiTree() {
        this.root = null;
    }

    public BiTree(BiTreeNode root) {
        this.root = root;
    } 

    /*格外注意 这里index是static的，是共享的，*/
    private static int index = 0;
    /**
     * @description 由标明空子树的先根遍历序列创建一颗二叉树
     *              可知由二叉树的先根遍历序列不能唯一确定一棵二叉树，如果能够在先根序列中加

入空子树的信息即可。
     * @param preStr
     * @author liuquan
     * @date  2015年12月29日
     */
    public BiTree(String preStr){
        char c = preStr.charAt(index++);
        if(c != '#'){
            this.root = new BiTreeNode(Character.valueOf(c));
            this.root.setLchild(new BiTree(preStr).getRoot());
            this.root.setRchild(new BiTree(preStr).getRoot());
        }  
        else
            this.root = null; 
    }


    /**
     * @description 先根遍历和中根遍历序列创建一颗二叉树算法
     *              1.取先根遍历序列的第一个结点作为根结点
     *              2.在中根遍历序列中寻找根结点，确定位置假设为i（0≤i≤count-1）
     *              3.在中根遍历序列中确定：根结点之前的i个结点构成左子树的中跟遍历序列，根结

点之后的count-i-1个结点构成右子树的中跟遍历序列
     *              4.在先根遍历序列中确定：根结点之后i个结点构成左子树的先根序列，剩下的

count-i-1个结点构成右子树的先根遍历
     *              5.根据3.和4.进行递归算法
     * @param preOrder 先根遍历序列
     * @param inOrder 中根遍历序列  
     * @param preIndex 新的先根遍历序列在preOrder的开始位置
     * @param inIndex 新的中根遍历序列在inOrder的开始位置
     * @param count 树中结点个数
     * @time 2015年12月2日 下午11:21:26
     */
    public BiTree(String preOrder, String inOrder, int preIndex, int inIndex, int count) {
        if(count > 0){
            // 取先根遍历序列的第一个结点作为根结点
            char r = preOrder.charAt(preIndex);
            // 寻找根结点在中根遍历序列中的位置
            int i = 0;
            for(; i < count; i++){
                if(r == inOrder.charAt(i + inIndex)){
                    break;
                }
            }            
            this.root = new BiTreeNode(Character.valueOf(r)); //建立树的根结点
            //建立树的左子树
            this.root.setLchild(new BiTree(preOrder, inOrder, preIndex + 1, inIndex, i).root);
            //建立树的右子树
            this.root.setRchild(new BiTree(preOrder, inOrder, preIndex + i + 1, inIndex + i + 1, 

count - i - 1).root);
        }
    }


    public BiTreeNode getRoot() {
        return root;
    }

    public void setRoot(BiTreeNode root) {
        this.root = root;
    }

    /**
     * @description 先根遍历 递归算法
     * @param T 二叉树的根结点
     * @time 2015年12月2日 下午11:21:56
     */
    public void preRootTraverse(BiTreeNode T) {
        if (T != null) {
            System.out.print(T.getData() + " ");
            preRootTraverse(T.getLchild());
            preRootTraverse(T.getRchild());
        }
    }

    /**
     * @description 中根遍历 递归算法
     * @param T 二叉树的根结点
     * @time 2015年12月2日 下午11:22:44
     */
    public void inRootTraverse(BiTreeNode T) {
        if (T != null) {
            inRootTraverse(T.getLchild());
            System.out.print(T.getData() + " ");
            inRootTraverse(T.getRchild());
        }
    }

    /**
     * @description 后根遍历 递归算法
     * @param T 二叉树的根结点
     * @time 2015年12月2日 下午11:22:56
     */
    public void postRootTraverse(BiTreeNode T) {
        if (T != null) {
            postRootTraverse(T.getLchild());
            postRootTraverse(T.getRchild());
            System.out.print(T.getData() + " ");
        }
    }

    /**
     * @description 先根遍历 非递归算法
     * @time 2015年12月2日 下午11:23:33
     */
    public void preRootTraverse() {
        BiTreeNode T = root;
        if (T != null) {            
            // 构造一个栈 存放临时数据
            LinkStack s = new LinkStack(); 
            s.push(T);
            while (!s.isEmpty()) {
                T = (BiTreeNode) s.pop();
                System.out.print(T.getData() + " ");
                while (T != null) {
                    if (T.getLchild() != null)
                        System.out.print(T.getLchild().getData() + " ");
                    if (T.getRchild() != null)
                        s.push(T.getRchild());
                    T = T.getLchild();
                }
            }
        }
    }

    /**
     * @description 中根遍历 非递归算法
     * @time 2015年12月2日 下午11:24:10
     */
    public void inRootTraverse() {
        BiTreeNode T = root;
        if (T != null) {
            LinkStack s = new LinkStack();
            s.push(T);
            while (!s.isEmpty()) {
                // 栈顶结点的所有左孩子结点入栈
                while (s.peek() != null) {
                    s.push(((BiTreeNode) s.peek()).getLchild());
                }
                // 空结点出栈
                s.pop();
                if (!s.isEmpty()) {
                    T = (BiTreeNode) s.pop();
                    System.out.print(T.getData() + " ");
                    s.push(T.getRchild());
                }
            }
        }
    }

    /**
     * @description 后根遍历 非递归算法
     *              flag用来标记栈顶元素是否被访问，true代表被访问。p指针指向遍历过程中最后一个被访问的结点，

若当前结点的右孩子为空或者就是p指针
     *              ，证明右子树遍历完成
     * @time 2015年12月2日 下午11:24:22
     */
    public void postRootTraverse() {
        BiTreeNode T = root;
        if (T != null) {
            LinkStack s = new LinkStack();
            s.push(T);
            boolean flag = false;
            BiTreeNode p = null;
            while (!s.isEmpty()) {
                // 栈顶结点的所有左孩子结点入栈
                while (s.peek() != null) {
                    s.push(((BiTreeNode) s.peek()).getLchild());
                }
                // 空结点出栈
                s.pop();
                while (!s.isEmpty()) {
                    T = (BiTreeNode) s.peek();
                    if (T.getRchild() == null || T.getRchild() == p) {
                        System.out.print(T.getData() + " ");
                        s.pop();
                        p = T;
                        flag = true;
                    } else {
                        s.push(T.getRchild());
                        flag = false;
                    }
                    if (!flag) {
                        break;
                    }
                }
            }
        }
    }

    /**
     * @description 层次遍历
     * @throws Exception
     * @time 2015年12月2日 下午11:24:56
     */
    public void levelTraverse() throws Exception {
        BiTreeNode T = root;
        if (T != null) {
            LinkQueue L = new LinkQueue(); // 构造队列
            L.offer(T);
            while (!L.isEmpty()) {
                T = (BiTreeNode) L.poll();
                System.out.print(T.getData() + " ");
                if (T.getLchild() != null)
                    L.offer(T.getLchild());
                if (T.getRchild() != null)
                    L.offer(T.getRchild());
            }
        }
    }

    /**
     * @description 查找值为x的结点
     * @param T 二叉树的根结点
     * @param x 要比较的值
     * @return
     * @time 2015年12月2日 下午11:27:34
     */
    public BiTreeNode searchNode(BiTreeNode T, Object x) {
        if (T != null) {
            // 对根结点进行判断
            if (T.getData().equals(x))
                return T;
            else {
                // 查找左子树
                BiTreeNode l = searchNode(T.getLchild(), x);
                // 若在左子树找到值为x的结点则返回该结点；否则，在右子树中查找该结点
                return l != null ? l : searchNode(T.getRchild(), x);
            }
        }
        return T;
    }

    /**
     * @description 计算二叉树中结点的个数 采用先根遍历
     * @param T 二叉树的根结点
     * @return 结点个数
     * @time 2015年12月2日 下午11:34:45
     */
    public int countNode(BiTreeNode T) {
        // 采用先根遍历的方式对二叉树进行遍历
        int count = 0;
        if (T != null) {
            ++count;
            count += countNode(T.getLchild());
            count += countNode(T.getRchild());
        }
        return count;
    }

    /**
     * @description 计算二叉树中结点的个数 采用层次遍历
     * @param T 二叉树的根结点
     * @return 结点的个数
     * @throws Exception
     * @time 2015年12月2日 下午11:39:29
     */
    public int countNode8levelTraverse(BiTreeNode T) throws Exception {
        int count = 0;
        if (T != null) {
            LinkQueue L = new LinkQueue();
            L.offer(T);
            while (!L.isEmpty()) {
                T = (BiTreeNode) L.poll();
                // 结点数增1
                ++count;
                // 左孩子非空 入队列
                if (T.getLchild() != null)
                    L.offer(T.getLchild());
                if (T.getRchild() != null)
                    L.offer(T.getRchild());
            }
        }
        return count;
    }

    /**
     * @description 计算二叉树的深度
     * @return 二叉树的深度
     * @param T
     *            二叉树的根结点
     * @time 2015年12月2日 下午11:44:35
     */
    public int getDepth(BiTreeNode T) {
        if (T != null) {
            // 左子树的深度
            int lDepth = getDepth(T.getLchild());
            // 右子树的深度
            int rDepth = getDepth(T.getRchild());
            // 返回左子树和右子树中深度的最大值加1
            return 1 + (lDepth > rDepth ? lDepth : rDepth);
        }
        return 0;
    }

    /**
     * @description 判断两颗二叉树是否相等的算法
     * @return 是否相等
     * @time 2015年12月2日 下午11:49:12
     */
    public boolean isEqual(BiTreeNode T1, BiTreeNode T2) {
        if (T1 == null && T2 == null) {
            return true;
        }
        if (T1 != null && T2 != null)
            // 根结点的值是否相等
            if (T1.getData().equals(T2.getData()))
                // 左子树是否相等
                if (isEqual(T1.getLchild(), T2.getLchild()))
                    // 右子树是否相等
                    if (isEqual(T1.getRchild(), T2.getRchild()))
                        return true;
        return false;
    }

    /**
     * @description 由顺序存储的完全二叉树建立一棵二叉树，其中index标识结点在顺序存储结构中的位置 
     * @param sqBiTree 顺序存储的完全二叉树序列
     * @param index 标识结点在顺序存储结构中的位置 
     * @return
     * @author liuquan
     * @date  2015年12月29日
     */
    public BiTreeNode createBiTree(String sqBiTree, int index){
        BiTreeNode root = null;
        if(index < sqBiTree.length()){  //位置不越界
            root = new BiTreeNode(Character.valueOf(sqBiTree.charAt(index))); 
            root.setLchild(createBiTree(sqBiTree, 2 * index + 1));
            root.setRchild(createBiTree(sqBiTree, 2 * index + 2));
        }
        return root;
    }
}

测试类Test ：

package BiTree;

public class Test {

    public static BiTree init() {
        BiTreeNode d = new BiTreeNode("D");
        BiTreeNode g = new BiTreeNode("G");
        BiTreeNode h = new BiTreeNode("H");
        BiTreeNode e = new BiTreeNode("E", g, null);
        BiTreeNode b = new BiTreeNode("B", d, e);
        BiTreeNode f = new BiTreeNode("F", null, h);
        BiTreeNode c = new BiTreeNode("C", f, null);
        BiTreeNode a = new BiTreeNode("A", b, c);
        return new BiTree(a);

    }

    public static void main(String[] args) throws Exception {
        BiTree bitree = init();   
        System.out.println(bitree.countNode(bitree.getRoot()));
        System.out.println(bitree.countNode8levelTraverse(bitree.getRoot()));

        // 根据前序、中序创建树
        String preOrder = "ABDEGCFH";
        String inOrder = "DBGEAFHC";
        BiTree T = new BiTree(preOrder, inOrder, 0, 0, preOrder.length());
        System.out.println("后根遍历：");
        T.postRootTraverse();

        // 根据标注了空子树的先序创建树
        System.out.println();
        String preStr = "AB##CD###";
        BiTree T2 = new BiTree(preStr);
        System.out.println("后根遍历：");
        T2.postRootTraverse(); 


        // 由完全二叉树的顺序存储结构建立二叉树存储结构
        System.out.println();
        String sqBiTree = "ABCDEFGH";
        BiTreeNode b = new BiTree().createBiTree(sqBiTree, 0);
        System.out.println("后根遍历：");
        new BiTree(b).postRootTraverse(); 

    } 
}
【数据结构与算法基础】树与二叉树的互化
wayne_lee_lwc的博客
12-11 4155
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
java数据结构与算法.pdf
01-04
Java作为广泛应用的编程语言，其在实现数据结构和算法时有着丰富的库支持和优秀的可读性。下面将对标题和描述中提到的一些关键知识点进行详细解释。 1. **数据结构**： - **稀疏数组**：当大量数据中大部分为零或...
根据带空指针的先序遍历结果建立二叉树
05-07
输入二叉树的带空指针的先序遍历结果，生成二叉树，返回指向二叉树根节点的指针。
简单介绍二叉树
weixin_44058932的博客
11-05 325
树 树是一种非线性的数据结构，是由 n (n>=0)个有限结点组成一个具有层次关系的集合.但其实在数据结构中，它是根部朝上，叶朝下的.如下图所示： 树新结构特点： 每个结点都有 0 个或多个子节点. 没有父结点的结点称为根结点. 每一个非根结点下有且只有一个父结点. 除了根结点以外，每个子结点都可以分成多个没有相交关系的子数. 数的部分名称概念： 节点的度：一个节点含有子树的个...
二叉树数组描述
Wenbin_Yang
05-17 649
#include<iostream> using namespace std; template <class T>class Tree { public: Tree(int size,T*pRoot);//创建树 ~Tree();//销毁 T *searchNode(int nodeIndex);//根据索引寻找结点 bool AddNode(int nodeInd
用一笔画描述二叉树遍历
JohnJim的博客
07-11 390
对于二叉树，包含深度遍历和广度遍历两种方式，其中深度遍历更为复杂，有前序、中序、后序三种方法。 前序、中序、后序三种方法的考查顺序一致，但是得到的结果不同，因为： 前序：考查到一个节点后，就输出该节点的值，并继续遍历其左右子节点，简称根左右 中序：考查到一个节点后，将其暂存，遍历完左子树后，再输出该节点的值，然后遍历右子节点，即左根右。 后序：考查到一个节点后，将其暂存，遍历完左右子树后，再输出该节点的值，即左右根。 三种方法的代码都是类似的，如下是利用栈遍历二叉树： class Solution:
java创建二叉树并遍历
benzhaohao的博客
11-07 1193
java在实现非递归先根，中根，后根遍历时需要用到链栈Linkstack类，实现非递归层次遍历需要用到链队列Linkqueue类，前面文章已经实现。 下面实现二叉链式存储结构 package practice3; public class bitreeNode { private Object data; //结点的数据域 private bitreeNode lchild,rchil
数据结构java语言描述课后答案.docx
04-01
标题提及的是“数据结构java语言描述课后答案”，这通常指的是学生在学习数据结构课程时，针对教材或课堂讲解的习题解答。这些答案涵盖了数据结构的基本概念、逻辑结构、存储结构以及算法的时间和空间复杂度分析。 ...
数据结构与算法分析（java语言描述）中文第二版以及习题答案
05-15
本资源包含了《数据结构与算法分析》一书的Java语言描述中文第二版，以及配套的习题答案，无论是英文还是中文，都能为学习者提供详实的学习材料。 在数据结构方面，书中会详细介绍各种基本和高级的数据组织方式，...
#数据结构与算法java实现 #包括排序，线性表，树，图，散列等基础数据结构.zip
最新发布
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
数据结构-二叉树（Java实现）
11-27
编程实现如下功能： 1、假设二叉树的结点值是字符，根据输入的一颗二叉树的标明了空子树的完整先根遍历序列，建立一棵以二叉链表表示的二叉树。 2、对二叉树进行先根、中根和后根遍历操作，并输出遍历序列，同时观察输出序列是否与逻辑上的序列一致。 3、统计二叉树的结点个数和叶子结点个数，并分别输出其值。
数据结构二叉树
06-15
数据库第六章 树和二叉树结构的描述以及计算等等，满二叉树，二叉树的度。
二叉树实现：公式化描述
weixin_30832405的博客
01-27 107
树的定义：树（ t r e e） t 是一个非空的有限元素的集合，其中一个元素为根（ r o o t），余下的元素（如果有的话）组成 t 的子树（ s u b t r e e）。树中层次最高的元素为根，其下一集的元素是余下元素所构成子树的根。 树的另一常用术语为级（level）。指定树根的级为1。 元素的度（degree of an element)是指其孩子的个数。叶节点的度为0.树的度是其...
java中先序创建一棵树,恳求大佬指点！！！首先标明空子树的先根遍历序列建立一棵二叉树...
weixin_30366015的博客
03-14 241
该楼层疑似违规已被系统折叠隐藏此楼查看此楼回复 甜味_猫 :public class BiTree {private BiTreeNode root;public BiTree(String str) {String s = str.replaceAll("#", "");char[] chars = s.toCharArray();root = new BiTreeNode(chars[0] ...
java中根遍历后根遍历构造,恳求大佬指点！！！首先标明空子树的先根遍历序列建立一棵二叉树...
weixin_28338005的博客
03-21 309
该楼层疑似违规已被系统折叠隐藏此楼查看此楼回复 甜味_猫 :public class BiTree {private BiTreeNode root;public BiTree(String str) {String s = str.replaceAll("#", "");char[] chars = s.toCharArray();root = new BiTreeNode(chars[0] ...
完全二叉树的定义
weixin_30352191的博客
08-20 1436
按照严蔚敏那本教材上的说法：一个深度为k，节点个数为 2^k - 1 的二叉树为满二叉树。这个概念很好理解， 就是一棵树，深度为k，并且没有空位。 首先对满二叉树按照广度优先遍历（从左到右）的顺序进行编号。 一颗深度为k二叉树，有n个节点，然后，也对这棵树进行编号，如果所有的编号都和满二叉树对应，那么这棵树是完全二叉树。 其实就是对于一棵树，每一层从左往右编号，不能中断编号，比如...
先序中序建立二叉树 Java实现
K3140911026的博客
09-05 1109
package fenshujs; import java.util.Scanner; public class bishi { private static class Node { public char s; public Node left = null; public Node right = null; } public static Node Cre
数据结构 — 二叉树（创建、遍历）java实现
PeersLee的博客
11-28 1172
1、二叉链式存储结构节点类 public class BiTreeNode { //域 public Object data; public BiTreeNode lchild,rchild; //构造空节点 public BiTreeNode() { this(null); } //构造左右孩子域为空的二叉树 public BiTreeNode(Object d
二叉树的三种遍历的非递归实现
lihappy999的专栏
03-09 491
三种遍历的非递归实现： //coder：LEE //20120309 #include #include #include using namespace std; struct BiTreeNode { int value; BiTreeNode *pLeft; BiTreeNode *pRight; }; void AddNode(BiTreeNode *&root,
Java描述数据结构：二叉树建模与Java应用
此外，还提到了相关的教材参考，如Sartaj Sanhi和Sichael Main编写的《数据结构、算法与应用:java语言描述》和《数据结构Java语言描述》，以及叶核亚、朱战立编著的Java版《数据结构》等。 最后，课程规定了严格的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值