Java 数据结构精讲：二叉树遍历算法与底层实现剖析

1.树型结构（了解）

1.1概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看
起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：有一个特殊的结点，称为根结点，根结点没有前驱结点除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个集合Ti (1 <= i <= m) 又是一棵与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继
**注意：**树是递归定义的。
树形结构中，子树之间不能有交集，否则就不是树形结构

1.2概念（重要）

结点的度：一个结点含有子树的个数称为该结点的度；如上图：A的度为6

树的度：一棵树中，所有结点度的最大值称为树的度；如上图：树的度为6

叶子结点或终端结点：度为0的结点称为叶结点；如上图：B、C、H、I...等节点为叶结点
双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点；如上图：A是B的父结点
孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点；如上图：B是A的孩子结点
根结点：一棵树中，没有双亲结点的结点；如上图：A
结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推
树的高度或深度：树中结点的最大层次；如上图：树的高度为4
树的以下概念只需了解，在看书时只要知道是什么意思即可：
非终端结点或分支结点：度不为0的结点；如上图：D、E、F、G...等节点为分支结点
兄弟结点：具有相同父结点的结点互称为兄弟结点；如上图：B、C是兄弟结点
堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点
结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先
子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙
森林：由m（m>=0）棵互不相交的树组成的集合称为森林

1.3树的表示形式（了解）

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，实际中树有很多种表示方式，如：双亲表示法， 孩子表示法、孩子双亲表示法、孩子兄弟表示法等等。我们这里就简单的了解其中最常用的孩子兄弟表示法。

1.4树的应用

文件系统管理（目录和文件）

2.二叉树（重点）

2.1概念

一棵二叉树是结点的一个有限集合，该集合：

或者为空
或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。

从上图可以看出：

二叉树不存在度大于2的结点

二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
注意：对于任意的二叉树都是由以下几种情况复合而成的：

2.2两种特殊的二叉树

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

2.3二叉树的性质

若规定根结点的层数为****1，则一棵非空二叉树的第i层上最多有(i>0)个结点
若规定只有根结点的二叉树的深度为****1，则深度为K的二叉树的最大结点数是(k>=0)
对任何一棵二叉树, 如果其**叶结点个数为n0,度为2的非叶结点个数为n2,则有n0＝n2＋**1（度为0的节点会比度为2的节点多一个）二叉树节点

一棵N个节点的树产生N-1条边
度为0的节点n0个，产生0条边
度为1的节点n1个，产生n1条边
度为2的节点n2个产生2*n2条边
n1+2*n2=N-1 表达式1
n0+n1+n2=N 表达式2
推出 n2+1=n0

具有n个结点的完全二叉树的深度****k log（n+1）为上取整
对于具有n****个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号则对于序号为i的结点有：
若i>0，双亲序号：****(i-1)/2；i=0**，i为根结点编号**，无双亲结点
若2i+1<n，左孩子序号：2i+1，否则无左孩子
若2i+2<n，右孩子序号：2i+2，否则无右孩子

某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（）
A 不存在这样的二叉树
B 200
C 198
D 199
2.在具有 2n 个结点的完全二叉树中，叶子结点个数为（）
A n
B n+1
C n-1
D n/2

3.一个具有767个节点的完全二叉树，其叶子节点个数为（）
A 383
B 384
C 385
D 386

4.一棵完全二叉树的节点数为531个，那么这棵树的高度为（）
A 11
B 10
C 8
D 12

2.4二叉树的存储

二叉树的存储结构分为：顺序存储和类似于链表的链式存储。
顺序存储在下节介绍。
二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式，具体如下：

2.5二叉树的基本操作

2.5.1前置说明

在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结
构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。

2.5.2二叉树的遍历

前中后序遍历
学习二叉树结构，最简单的方式就是遍历。所谓遍历****(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题**(比如：打印节点内容、节点内容加
1)。遍历是二叉树上最重要的操作之一，是二叉树上进行其它运算之基础。

在遍历二叉树时，如果没有进行某种约定，每个人都按照自己的方式遍历，得出的结果就比较混乱，**如果按**照某种规则进行约定，则每个人对于同一棵树的遍历结果肯定是相同的**。如果N代表根节点，L代表根节点的左子树，R代表根节点的右子树，则根据遍历根节点的先后次序有以下遍历方式：
NLR：前序遍历(Preorder Traversal 亦称先序遍历)------访问根结点--->根的左子树--->根的右树。

A B D C E F
LNR：中序遍历(Inorder Traversal)------根的左子树--->根节点--->根的右子树。
D B A E C F
LRN：后序遍历(Postorder Traversal)------根的左子树--->根的右子树--->根节点。
D B E C F A

1.某完全二叉树按层次输出（同一层从左到右）的序列为 ABCDEFGH 。该完全二叉树的前序序列为()
A: ABDHECFG B: ABCDEFGH C: HDBEAFCG D: HDEBFGCA
2.二叉树的先序遍历和中序遍历如下：先序遍历：EFHIGJK;中序遍历：HFIEJKG.则二叉树根结点为()
A: E B: F C: G D: H

3.设一课二叉树的中序遍历序列：badce，后序遍历序列：bdeca，则二叉树前序遍历序列为()
A: adbce B: decab C: debac D: abcde

4.某二叉树的后序遍历序列与中序遍历序列相同，均为 ABCDEF ，则按层次输出(同一层从左到右)的序列为()
A: FEDCBA B: CBAFED C: DEFCBA D: ABCDEF

【参考答案】 1.A 2.A 3.D 4.A

二叉树初始化

java 复制代码

    static class Node{
        char val;
        Node left;
        Node right;

        public Node(char val){
            this.val = val;
        }
    }
    public Node createTree(){
        Node A = new Node('A');
        Node B = new Node('B');
        Node C = new Node('C');
        Node D = new Node('D');
        Node E = new Node('E');
        Node F = new Node('F');
        Node G = new Node('G');
        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        C.left = F;
        C.right = G;
        return A;
    }

二叉树先序遍历

java 复制代码

    void preOrder(Node root){
if(root==null){
return;
}
System.out.print(root.val);
preOrder(root.left);
preOrder(root.right);
    }

二叉树中序遍历

java 复制代码

    void inOrder(Node root){
        if(root==null){
            return;
        }
        preOrder(root.left);
        System.out.print(root.val);
        preOrder(root.right);
    }

二叉树后序遍历

java 复制代码

 void postOrder(Node root){
        if(root==null){
            return;
        }
        preOrder(root.left);
        preOrder(root.right);
        System.out.print(root.val);
    }

层序遍历
层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。
二叉树前序非递归遍历实现、

java 复制代码

   List<Integer> list=new ArrayList<>();
        public List<Integer> preorderTraversal(TreeNode root) {
        
        if(root==null){
            return list;
        }
        list.add(root.val);
        preorderTraversal(root.left);
        preorderTraversal(root.right);
        return list;

    }

java 复制代码

   List<Integer> list=new ArrayList<>();
        public List<Integer> preorderTraversal(TreeNode root) {
        
        if(root==null){
            return list;
        }
        list.add(root.val);
      List<Integer> lefttree = preorderTraversal(root.left);
         list.addAll(leftree);
      List<Integer> righttree = preorderTraversal(root.right);
    list.addAll(rightree);
        return list;

    }

获取节点个数

java 复制代码

public static int size1=0;
    public void sizoe(Node root){
        if(root==null){
            return;
        }
        size1++;
        sizoe(root.left);
        sizoe(root.right);
    }

获取叶子节点

java 复制代码

    public int leaves(Node root){
        if(root==null){
            return 0;
        }
        if(root.left==null && root.right==null){
            return 1;
        }
        return leaves(root.left)+leaves(root.right);
    }

获取第k层节点个数

java 复制代码

    public int getleaves(Node root,int i){
        int j=i;
        if(root==null){
            return 0;
        }
        if(j==1){
            return 1;
        }
     return   getleaves(root.left,j-1)
        +getleaves(root.right,j-1);
    }

// 获取二叉树的高度时间复杂度和空间复杂度分别为 O(N) O(log2N)

java 复制代码

    int getHeight(Node root){
        if(root==null){
            return 0;
        }
        int l=getHeight(root.left);
        int r=getHeight(root.right);
        return Math.max(l,r)+1;
    }

查找val元素

java 复制代码

public Node findVal(Node root,char val){
        if(root==null){
           return null;
        }
        if(root.val==val){
            return root;
        }
     Node l=   findVal(root.left,val);
        if(l!=null){
            return l;
        }
       Node r= findVal(root.right,val);
        if(r!=null){
            return r;
        }
        return null;
    }

检查两颗树是否相同

java 复制代码

    public boolean isSameTree(TreeNode p1, TreeNode p2) {
        //先判断结构是否一样
           if(p1!=null&&p2==null||p1==null&&p2!=null){
            return false;
        }
         //他们的是否同时为空，同时为空那么他们的结构一样
        if(p1==null&&p2==null){
            return true;
        }
         //结构一样以后，判断值是否一样
        if(p1.val!=p2.val){
            return false;
        }
        return isSameTree(p1.left,p2.left) && isSameTree(p1.right,p2.right);
        
    }

另一颗树的子树

我们去遍历root树里面的节点，找到有没有和subroot树一样的树，还需要利用上面的算法

1.当前子树和根节点是否一样？

2.判断子树是不是当前root的左子树一样？

3.判断子树是不是当前root的右子树一样？

java 复制代码

    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if(root==null){
            return false;
        }
从根开始判断是否一样
        if(isSameTree(root,subRoot)){
            return true;
        }
     if(isSubtree(root.left,subRoot)){
         return true;
          }
     if(isSubtree(root.right,subRoot)){
         return true;
     }
   return false;
    }
        public boolean isSameTree(TreeNode p1, TreeNode p2) {
           if(p1!=null&&p2==null||p1==null&&p2!=null){
            return false;
        }
        if(p1==null&&p2==null){
            return true;
        }
        if(p1.val!=p2.val){
            return false;
        }
        return isSameTree(p1.left,p2.left) && isSameTree(p1.right,p2.right);
        
    }

翻转二叉树。

首先将root节点的左右子树进行交换，然后再把root的letf子树放入invertTree进行递归，root的right子树放入invertTree进行递归，最后返回根节点

java 复制代码

    public TreeNode invertTree(TreeNode root) {
        if(root==null){
            return null;
        }
     TreeNode tmp=root.left;
     root.left=root.right;
     root.right=tmp;
        invertTree(root.left);
         invertTree(root.right);
return root; 
    }

对称二叉树

我们的思路是，分成两部分，第一部分判断根节点是否为空，如果为空就是对称的，如果不为空，那么就进行左右树的判断，第一就是他们之间一个为空一个不为空的情况，然后就是他们不为空的时候判断是否相等，

java 复制代码

  public boolean isSymmetric(TreeNode root) {
        if(root==null){
            return false;
        }
        return isSymmetriccha(root.left,root.right);

    }

     public boolean isSymmetriccha(TreeNode leftree,TreeNode rightree) {
        if(leftree==null&&rightree!=null||leftreet!=null&&rightree==null){
            return false;
        }
        if(leftree==null&&rightree==null){
            return true;
        }
        if(leftree.val!=rightree.val){
            return false;
        }
    return isSymmetriccha(leftree.left,rightree.right) && isSymmetriccha(leftree.right,rightreet.left);
    }

判断一颗二叉树是否是平衡二叉树。

对于一颗平衡二叉树，他的左右子树高度差不超过1，如果超过则不是平衡二叉树，同时他的每一棵子树的左右树高度差也是不能超过1，所以我们的思路是遍历每一个节点，并且去去求节点的左右树高度差是不是超过1

java 复制代码

    public boolean isBalanced(TreeNode root) {
        if(root==null){
            return true;
        }
        int c= Math.abs(getHeight(root.left)-getHeight(root.right));
              if(c>=2){
return false;
              }
             return isBalanced(root.left) && isBalanced(root.right);
    }
    public int getHeight(TreeNode root){
        if(root==null){
            return 0;
        }
        int l=getHeight(root.left);

二叉搜索树与双向链表

二叉搜索的特点是左树所有节点比根小，右树所有节点比根大，

因此二叉搜索的中序遍历就是有序的，如何把他变成一个双向链表呢，我们的思路是把他们的 right(红色)作为后继，left作为前驱(绿色)，

当我们不断进行中序遍历，来带最左边节点1以后，此时root就是1，我们定义一个prev空指针，来进行改接，首先是将root的left指针指向prev，然后把root赋给prev，prev就是1，此时程序返回到root=2这里，prev是1，我们将root的left指针指向prev，然后呢再将prev的right指针指向root，再将root赋给prev，prev变成2，然后呢根据中序遍历，又来到root=3在这里，依次这样下去，同时呢我们要确定prev是否为空，为空就不能使用right指针，就能把二叉搜索树变成双向链表

java 复制代码

    public TreeNode Convert(TreeNode pRootOfTree) {
        if(pRootOfTree==null){
            return null;
        }
        Convertchai(pRootOfTree);
        TreeNode head=pRootOfTree;
        while(head.left!=null){
            head=head.left;
        }
        return head;
    }

     public void Convertchai(TreeNode root) {
        if(root==null){
            return;
        }
        Convertchai(root.left);
        root.left=prev;
        if(prev!=null){
        prev.right=root;
        }
        prev=root;
        Convertchai(root.right);
    }

根据输入字符创建二叉树， ABC##DE#G##F### 其中"#"表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。

我们的思路是用一个字符串来传入，对这个字符串进行遍历，遇到一个字符就创建节点，如何遇到#，就让i往后走，例如我们对ABC##DE#G##F###，一直到c节点的时候，然后我们让i++，遇到#，不对这个做任何操作，只让他返回空，于是c的左右都是空，然后我们递归回到b继续开始创建，

java 复制代码

 public  static int i=0;
   public static Treenode createtree(String str){
   Treenode root=null;
   if(str.charAt(i)!='#'){
        root=new Treenode(str.charAt(i));
        i++;
        root.left=createtree(str);
        root.right=createtree(str);
   }
   else{
          i++;
       }
    return root;
   }

二叉树的层序遍历

我们的思路是对二叉树进行先序遍历，同时定义一个队列，将根节点A入队，然后开始队列不为空的循环，循环里面，定义cur指针接受队列里面弹出的元素，然后对这个节点进行判断，他的左边是否为空，不为空入队，在判断右边是否为空，不为空入队，一直循环下去，直到队列为空

java 复制代码

public void levelorder(Node root){
        if(root==null){
            return;
        }
    Queue<Node> queue=new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            Node cur=queue.poll();
            System.out.print(cur.val);
            if(cur.left!=null){
                queue.offer(cur.left);
            }
            if(cur.right!=null){
                queue.offer(cur.right);
            }
        }
}

判断一颗二叉树是否为完全二叉树

java 复制代码

public boolean isCompletetree(Node root){
        if(root==null){
            return true;
        }
        Queue<Node> queue=new LinkedList<>();

        while(!queue.isEmpty()){
            Node cur=queue.poll();
            if(cur!=null){
                queue.offer(cur.left);
                queue.offer(cur.right);
            }
            else{
                break;
            }
        }
        while(!queue.isEmpty()){
            Node cur=queue.poll();
            if(cur!=null){
                return false;
            }
        }
        return true;
    }

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

寻找pq公共祖先，我们的思路是对这颗树进行遍历，如果p在root上，那么root就是公共祖先，如果q在root上，他是公共祖先,然后我们先序递归下去，同时定义leftree指针和rightree指针，去接收左右子树中是否存在q或者q，如果左树右树同时不为空，那么这个root就是公共祖先，如果只是左树不为空，则就是返回左树，同理也是返回右树

java 复制代码

   public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root==null){
            return null;
        }
        if(root==p||root==q){
            return root;
        }
        TreeNode lefttree=lowestCommonAncestor(root.left,p,q);
        TreeNode righttree=lowestCommonAncestor(root.right,p,q);
       if(lefttree!=null&&righttree!=null){
        return root;
       }
       else if(lefttree!=null){
        return lefttree;
       }
       else{
return righttree;
       }
    }

获得节点路径

9. 根据一棵树的前序遍历与中序遍历构造二叉树。

我们的思路是因为前序的第一个接触到的字符就是根，然后是根的左右，而中序遍历，是先左子树再根最后右树，比如定义一个i=0;一开始前序遍历里面的e就是整颗的根，然后我们在中序里面找到e，通过e把他们分为根e的左右子树部分，在中序里面找到e的下标，在e之前就是左子树部分，e的右边就是右树部分，随后先序里面再后走i++,这个时候来到了e的左树根f，我们同样去中序里面找到f，并返回他的下标，f之前就是他的左树部分，e的后面就是他的右数部分，依次这样递归下去，然后直到be<end返回

java 复制代码

   public int preind=0;
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return createTree(preorder,inorder,0,inorder.length-1);
    }

    public TreeNode createTree(int[] preorder,int[] inorder,int be ,int end) {
        //root没有子树了
        if(be>end){
            return null;
        }
        TreeNode root=new TreeNode(preorder[preind]);
        int rootindex=findval(inorder,be,end,preorder[preind]);

        preind++;
        root.left=createTree(preorder,inorder,be,rootindex-1);
        root.right=createTree(preorder,inorder,rootindex+1,end);

        return root;
    }
    public int findval(int []arr,int begin,int end,int val){
        for(int i=begin;i<=end;i++){
            if(arr[i]==val){
                return i;
            }
        }
        return -1;
    }

二叉树创建字符串。

java 复制代码

    public String tree2str(TreeNode root) {
        if(root==null){
            return null;
        }
        StringBuilder str=new StringBuilder();
        creat(root,str);
        return str.toString();
    }
    public void creat(TreeNode root,StringBuilder str){
        if(root==null){
            return ;
        }
        str.append(root.val);
        if(root.left!=null){
        str.append("(");
        creat(root.left,str);
        str.append(")");
        }
        else{
            if(root.right==null){
                return ;
            }
            else{
                str.append("()");
            }
        }
        if(root.right!=null){
            str.append("(");
            creat(root.right,str);
            str.append(")");
        }
        else{
            return;
        }
    }

二叉树前序非递归遍历实现。

java 复制代码

    void setPrev1(Node root){
        if(root==null){
            return;
        }
        Node cur=root;
        Stack<Node> stack=new Stack<>();
        while(cur!=null||!stack.isEmpty()){
            while(cur!=null){
                stack.push(cur);
                System.out.print(cur.val);
                cur=cur.left;
            }
            Node top =stack.pop();
            cur=top.right;
        }
    }

二叉树中序非递归遍历实现。

java 复制代码

    void inorderNO(Node root){
        if(root==null){
            return;
        }
        Node cur=root;
        Stack<Node> stack=new Stack<>();
        while(cur!=null||!stack.isEmpty()){
            while(cur!=null){
                stack.push(cur);
                cur=cur.left;
            }
            Node top =stack.pop();
            System.out.print(cur.val);
            cur=top.right;
        }
    }

二叉树后序非递归遍历实现。

java 复制代码

    void preOrder1(Node root){
        if(root==null){
            return;
        }
        Stack<Node> stack=new Stack<>();
        Node cur=root;
        Node temp=null;
        while(cur!=null||!stack.isEmpty()){
            while(cur!=null){
                stack.push(cur);
                cur=cur.left;
            }
            Node top=stack.peek();
            if(top.right==null||top.right==temp){
                System.out.print(cur.val);
                stack.pop();
               temp=top;
            }
            else{
                cur=top.right;
            }
        }
    }

本文摘要：本文系统介绍了树型结构和二叉树的定义、性质及操作。首先阐述了树的基本概念（根节点、度、层次等）和表示方法，重点讲解了二叉树的两种特殊类型（满二叉树和完全二叉树）及其性质。详细说明了二叉树的存储结构（顺序/链式）和基本操作，包括前序/中序/后序/层序遍历的实现方法（递归与非递归），以及计算节点数、查找节点、判断树结构等常见算法。最后介绍了二叉树在构建、转换等方面的应用实例，如根据遍历序列构建二叉树、二叉搜索树转双向链表等典型问题解决方案。全文通过代码示例和图示相结合的方式，全面展示了二叉树的理论知识和实践应用。

Java 数据结构精讲：二叉树遍历算法与底层实现剖析

**1.**树型结构（了解）

1.1****概念

1.2****概念（重要）

1.3****树的表示形式（了解）

1.4****树的应用

**2.**二叉树（重点）

2.1****概念

2.2****两种特殊的二叉树

2.3****二叉树的性质

2.4****二叉树的存储

2.5****二叉树的基本操作

2.5.1****前置说明

2.5.2****二叉树的遍历

1.树型结构（了解）

1.1概念

1.2概念（重要）

1.3树的表示形式（了解）

1.4树的应用

2.二叉树（重点）

2.1概念

2.2两种特殊的二叉树

2.3二叉树的性质

2.4二叉树的存储

2.5二叉树的基本操作

2.5.1前置说明

2.5.2二叉树的遍历