数据结构之二叉树

crazy_xieyi

已于 2022-11-20 11:30:24 修改

阅读量931

点赞数 46

分类专栏：数据结构与算法文章标签：数据结构二叉树 java

于 2022-10-04 08:26:40 首次发布

本文链接：https://blog.csdn.net/crazy_xieyi/article/details/127051627

版权

数据结构与算法专栏收录该内容

23 篇文章 1 订阅

订阅专栏

文章目录

一、二叉树相关概念
二、二叉树的性质
三、二叉树的基本操作
1.前序遍历
2.中序遍历
3.后序遍历
4.层序遍历
5.获取树中节点的个数
6.获取叶子节点的个数
7.获取第K层节点的个数
8.获取二叉树的高度
9.检测值为value的元素是否存在
10.判断一棵树是不是完全二叉树

一、二叉树相关概念

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

结点的度：一个结点含有子树的个数称为该结点的度

树的度：一棵树中，所有结点度的最大值称为树的度

叶子结点或终端结点：度为0的结点称为叶结点

双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点

孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点

根结点：一棵树中，没有双亲结点的结点

结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推

树的高度：树中结点的最大层次

注意：

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

2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

二、二叉树的性质

1. 若规定 根结点的层数为 1，则一棵 非空二叉树的第 i 层上最多有 (i>0) 个结点。

2. 若规定只有 根结点的二叉树的深度为 1，则 深度为 K 的二叉树的 最大 结点数是 2^k - 1(k>=0)

2^0 + 2^1 + ...... + 2^(k-1) = 2^k -1

3. 对任何一棵二叉树, 如果其 叶结点个数为 n0, 度为 2 的非叶结点个数为 n2, 则有 n0 ＝ n2 ＋ 1

假设：任意一颗二叉树有N个节点，那么就有N-1条边。

度为0设为n0，能产生0条边；度为1设为n1，能产生n1条边；度为2设为n2，能产生n2*2条边；则N = n0 + n1 + n2，N - 1 = n1 + n2*2; 所以推出公式： n0 ＝ n2 ＋ 1

4. 具有 n 个结点的完全二叉树的深度 k 为 上取整。（由第二点性质可以得到）

5. 对于具有 n 个结点的完全二叉树，如果按照 从上至下从左至右的顺序对所有节点从 0 开始编号，则对于 序号为 i 的结点有：左孩子小标：2*i + 1；右孩子下标：2*i + 2

三、二叉树的基本操作

前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点--->根的左子树--->根的右子树。前序遍历示意图如下：

中序遍历(Inorder Traversal)——根的左子树--->根节点--->根的右子树。

后序遍历(Postorder Traversal)——根的左子树--->根的右子树--->根节点。

如何根据遍历结果构造出完整的二叉树呢？

可以根据前序+中序，或者中序+后序就可以构建出来，但是前序+后序是不能的，因为构建就一定需要中序遍历的结果来确定根节点的位置。

1.前序遍历代码

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

2.中序遍历代码

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

3.后序遍历代码

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

4.层序遍历代码

 public void levelOrder(TreeNode root) {
        if(root == null) {
            return;
        }
        Queue<TreeNode> qu = new LinkedList<>();
        qu.offer(root);
        while (!qu.isEmpty()) {
            TreeNode cur = qu.poll();
            System.out.print(cur.val+" ");
            if(cur.left != null) {
                qu.offer(cur.left);
            }
            if(cur.right != null) {
                qu.offer(cur.right);
            }
        }
    }

分层遍历：

public List<List<Character>> levelOrder2(TreeNode root) {
        List<List<Character>> list = new ArrayList<>();

        if(root == null) {
            return list;
        }
        Queue<TreeNode> qu = new LinkedList<>();
        qu.offer(root);
        while (!qu.isEmpty()) {
            int size = qu.size();//2  //如何确定每一层？
            List<Character> tmp = new ArrayList<>();
            while (size > 0) {
                TreeNode cur = qu.poll();
                size--;//0
                //System.out.print(cur.val + " ");
                tmp.add(cur.val);
                if (cur.left != null) {
                    qu.offer(cur.left);
                }
                if (cur.right != null) {
                    qu.offer(cur.right);
                }
            }
            list.add(tmp);
        }
        return list;
    }

5.获取树中节点的个数代码

 //方法一：遍历
public static int nodeSize = 0;
    public int size(TreeNode root) {
        if(root == null) {
            return 0;
        }
        nodeSize++;
        size(root.left);
        size(root.right);
        return nodeSize;
    }

//递归思路
public int size(TreeNode root) {
        if(root == null) {
            return 0;
        }
        return size(root.left)+size(root.right)+1;
    }

6.获取叶子节点的个数代码

 //递归思路
     int getLeafNodeCount(TreeNode root) {
        if(root == null) {
            return 0;
        }
        if(root.left == null && root.right == null) {
            return 1;
        }
        return getLeafNodeCount(root.left) +
                getLeafNodeCount(root.right);
    }

//遍历
    public static int leafSize = 0;
    void getLeafNodeCount(TreeNode root) {
        if(root == null) {
            return ;
        }
        if(root.left == null && root.right == null) {
            leafSize++;
        }
        getLeafNodeCount(root.left);
        getLeafNodeCount(root.right);
    }

7.获取第K层节点的个数代码

int getKLevelNodeCount(TreeNode root,int k) {
        if(root == null || k <= 0) {
            return 0;
        }
        if(k == 1) {
            return 1;
        }
        return getKLevelNodeCount(root.left,k-1) +
                getKLevelNodeCount(root.right,k-1);
    }

8.获取二叉树的高度代码

public int getHeight(TreeNode root) {
        if(root == null) {
            return 0;
        }
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);
        return leftHeight > rightHeight ? leftHeight+1 : rightHeight+1;
    }

9.检测值为value的元素是否存在代码

 public TreeNode find(TreeNode root, char val) {
        if(root == null) {
            return null;
        }
        if(root.val == val) {
            return root;
        }
        TreeNode ret1 = find(root.left,val);
        if(ret1 != null) {
            return ret1;
        }
        TreeNode ret2 =  find(root.right,val);
        if(ret2 != null) {
            return ret2;
        }
        return null;
    }

10.判断一棵树是不是完全二叉树

 public boolean isCompleteTree(TreeNode root) {
        if(root == null) {
            return true;
        }
        Queue<TreeNode> qu = new LinkedList<>();
        qu.offer(root);
        while (!qu.isEmpty()) {
            TreeNode cur = qu.poll();
            if(cur != null) {
                qu.offer(cur.left);
                qu.offer(cur.right);
            }else {
                break;
            }
        }
        //判断队列剩下的值 是否有 非null的数据
        while (!qu.isEmpty()) {
            TreeNode pop = qu.poll();
            if(pop != null) {
                return false;
            }
        }
        return true;
    }