代码随想录 Day-13

二叉树的理论基础

树的定义：树是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。

二叉树的定义：二叉树是每个节点最多有两个子树的树结构。它有五种基本形态：二叉树可以是空集；根可以有空的左子树或右子树；活着左、右子树皆为空。

一、二叉树的种类

1、满二叉树（每一个节点的度不是2个就是0个，满满的，没有少也没有多的，而且同一个度的节点都是在同一行，除了头节点）

2、完全二叉树（在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值）

其实完全二叉树与满二叉树的区别可以类似只看只有0个度的节点是否只在用一层 

3、二叉搜索树（这个二叉树是有数值的，而且按照一定的规律排序）

• 若根节点的左子树不为空，则左子树上面所有的值都小于根节点的值。
• 若根节点的右子树不为空，则右子树上面所有的值都大于根节点的值。
• 根节点的左、右子树也是二叉排序树。

4、平衡二叉搜索树（它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树）

二、二叉树的存储的方式

二叉树可以是链式存储，还可以是顺序存储

顺序存储数据是用数组实现，在内存中是连续分布的；而链式存储是用指针实现，利用指针将各地址的数据串连起来，所以不是连续分布的。

在数组中，实现二叉树的方式如下：

如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。

三、二叉树的遍历方式

1. 深度优先遍历：先往深走，遇到叶子节点再往回走。
2. 广度优先遍历：一层一层的去遍历。

（叶子节点是指0度的节点，处于末端，称为叶子）

• 深度优先遍历
  • 前序遍历（递归法，迭代法）
  • 中序遍历（递归法，迭代法）
  • 后序遍历（递归法，迭代法）

其实有个很好记的方式：所谓前中后是中间的位置在哪里，左右都是一直在捆绑在一起的，所以前序就是说“中”在最前面，其后就是“左右”，中序和后序同理的意思。

• 广度优先遍历
  • 层次遍历（迭代法）

递归遍历

1、前序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        preorder(root,result);
        return result;

    }

    //递归第一步：确定递归的函数和返回值
    //root 是二叉树，result是前序遍历的结果
    public void preorder( TreeNode root, List<Integer> result){
        //递归第二步：确定终止条件（位置是在前面的）
        if(root == null){
            return;
        }

        //递归第三步：确定单层递归的逻辑
        result.add(root.val);           //中
        preorder(root.left,result);     //左
        preorder(root.right,result);    //右
    }
}

2、中序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        inorder(root,result);
        return result;
    }

    //递归的第一步：确定递归的参数和返回值
    public void inorder(TreeNode root, List<Integer> result){
        //递归的第二步：确定终止的条件
        if(root == null){
            return;
        }

        //递归的第三步：确定单层递归的逻辑
        inorder(root.left,result);      //左
        result.add(root.val);           //中
        inorder(root.right,result);     //右
    }
}

3、后序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        postorder(root,result);
        return result;

    }


    //递归的第一步：确定递归的参数以及返回值
    public void postorder(TreeNode root,List<Integer> result){
        //递归的第二步：确定终止条件
        if(root == null){
            return;
        }

        //递归的第三步：确定单层递归的逻辑
        postorder(root.left,result);    //左
        postorder(root.right,result);   //右
        result.add(root.val);           //中
    }
}