二叉树

树的简介

树是一种非线性结构, 树状结构是结点间有分支的, 层次的结构.

一些基本术语

  • 度数:一个结点的子树个数。
  • 树叶:没有子树的结点称为树叶或终端结点。
  • 双亲结点或父节点:若一个结点含有子节点,则这个结点称为子节点的父节点。
  • 孩子节点或子节点:一个结点含有的子树的根结点称为该节点的子节点。
  • 层数:定义树根的层数为1,其他结点的层数等于其父母结点的层数加1。
  • 高度或深度:树中结点的最大层数,规定空树的高度为0。

二叉树

概念:
一棵二叉树是结点的一个有限集合,该集合或者为空,或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
二叉树的特点:

  • 每个结点最多有两棵子树,即二叉树不存在度大于 2 的结点。
  • 二叉树的子树有左右之分,其子树的次序不能颠倒,因此二叉树是有序树

二叉树的基本形态


上图给出了几种特殊的二叉树形态,从左往右依次是:空树、只有根节点的二叉树、节点只有左子树、节点只有右子树、节点的左右子树均存在,一般二叉树都是由上述基本形态结合而形成的。

两种特殊的二叉树

  • 满二叉树: 一个二叉树,如果每一个层的结点数都达到最大值,则这个二叉树就是满二叉树。也就是说,如果一个二叉树的层数为K,且结点总数是2^k-1 ,则它就是满二叉树。
  • 完全二叉树: 完全二叉树是效率很高的数据结构,完全二叉树是由满二叉树而引出来的。对于深度为K的,有n个结点的二叉树,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

二叉树的性质

  • 若规定根节点的层数为1,则一棵非空二叉树的第i层上最多有2^{i-1}(i>0)个结点
  • 若规定只有根节点的二叉树的深度为1,则深度为K的二叉树的最大结点数是2^k-1(k>=0)
  • 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0=n2+1
  • 具有n个结点的完全二叉树的深度k为log_2(n+1)上取整
  • 对于具有n个结点的完全二叉树,如果按照从上至下从左至右的顺序对所有节点从0开始编号,则对于序号为i的结点有:
  • 若i>0,双亲序号:(i-1)/2;i=0,i为根节点编号,无双亲节点
  • 若2i+1<n,左孩子序号:2i+1,否则无左孩子
  • 若2i+2<n,右孩子序号:2i+2,否则无右孩子

二叉树的存储

二叉树的存储方式分为:顺序存储和类似于链表的链式存储

class Node{
    //孩子表示法
    int val;
    Node left;
    Node right;
}
 class Node{
    //孩子双亲表示法
    int val;
    Node left;
    Node right;
    Node parent;
}

我们看一下这个二叉树的前中后序遍历结果:

如果N代表根节点,L代表根节点的左子树,R代表根节点的右子树,则根据遍历根节点的先后次序有以下遍历方式:

  • NLR(前序遍历):先访问根节点,再遍历左子树,再遍历右子树
  • LNR(中序遍历):先遍左子树,再访问根节点,再遍历右子树
  • LRN(后续遍历):先遍历左子树,再遍历右子树,再访问根节点

前序遍历结果:A B D E C F G
中序遍历结果:D B E A F C G
后序遍历结果:D E B F G C A

先定义二叉树的节点

class TreeNode{
    char val;
    TreeNode left;
    TreeNode right;

    public TreeNode(char val) {
        this.val = val;
        left = null;
        right = null;
    }
}

手动创建二叉树

 public static TreeNode build() {
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');

        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        C.left = F;
        C.right = G;
        return A;
    }

先序遍历

 public static void preTraverse(TreeNode root) {
        if(root == null) {
            return;
        }
        System.out.print(root.val + " ");
        preTraverse(root.left);
        pretTraverse(root.right);
    }

中序遍历

 public static void inTraverse(TreeNode root) {
        if(root == null) {
            return;
        }
        inTraverse(root.left);
        System.out.print(root.val + " ");
        inTraverse(root.right);
    }

后续遍历

 public static void postTraverse(TreeNode root) {
        if(root == null) {
            return;
        }
        postTraverse(root.left);
        postTraverse(root.right);
        System.out.println(root.val);
    }

构建二叉树

构建二叉树的方式:

  • 根据前序和中序构建树。
  • 根据中序和后序构建树。

根据前序和中序构造二叉树

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return build(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
    }
    public TreeNode build(int[] preorder, int start, int end, int[] inorder, int start1, int end1) {
        if(start > end || start1 > end1) {
            return null;
        }
        int rootVal = preorder[start];
        int index = 0;
        while(index < inorder.length) {
            if(inorder[index] != rootVal) {
                index++;
            } else {
                break;
            }
        }
        int left = index - start1;
        TreeNode root = new TreeNode(rootVal);
        root.left = build(preorder, start + 1, start + left , inorder, start1, index - 1);
        root.right = build(preorder, start + left + 1, end, inorder, index + 1, end1);
        return root;
    } 
}

根据中序和后序构造二叉树

class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        return build(inorder, 0, inorder.length - 1, postorder, 0, postorder.length - 1);
    }

    public TreeNode build(int[] inorder, int start, int end, int[] postorder, int start1, int end1) {
        if(start > end || start1 > end1) {
            return null;
        }
        int rootVal = postorder[end1];
        int index = 0;
        while (index < inorder.length) {
            if (inorder[index] == rootVal) {
                break;
            } else {
                ++index;
            }
        }
        int left = index - start;
        
        TreeNode root = new TreeNode(rootVal);
        root.left = build(inorder, start, index - 1, postorder, start1, left + start1 - 1);
        root.right = build(inorder, index + 1, end, postorder, left + start1, end1 - 1);
        return root;
    }
}
最后编辑于 :
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成,浏览时请结合常识与多方信息审慎甄别。
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容