二叉树部分: 种类，定义，遍历方法

代码随想录算法训练营第12天 | 二叉树部分: 种类，定义，遍历方法

二叉树部分

理论基础

二叉树的种类， 存储方式， 遍历方式，二叉树的定义
二叉树的种类：满二叉树，完全二叉树，二叉排序树(二叉搜索树)，平衡二叉搜索树(树是一个空树或者它的左右子树的高度差不超过1)
存储方式：链式，顺序(数组)

遍历方式：深度优先遍历(先序，中序，后续)，广度优先遍历(层次遍历)
二叉树的定义：
二叉树的定义代码：

class TreeNode{
	int val;
	TreeNode left;
	TreeNode right;
	public TreeNode(){}
	public TreeNode(int val){
	this.val=val;
	}
	//这边忘记了
	public TreeNode(int val，TreeNode left,TreeNode right){
	this.val=val;
	this.left=left;
	this.right=right;
	}
}

递归遍历(这边之前刷的不好，感觉直接写的话不会)

前序遍历，中序遍历，后序遍历

基本步骤：
参数和返回值
终止条件
确定单层递归的逻辑

public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list=new LinkedList<>();
       preOrder(root,list);
       return list;
    }
    //返回值和参数：因为最后需要输出链表，所以传入的参数需要带上链表存放每一次遍历的值
    //不需要返回值
    public void preOrder(TreeNode cur,List<Integer> list){
a        //终止条件:当当前节点为空的时候，本层递归就直接结束
        if(cur==null){
            return ;
        }
        //本层递归的逻辑，先根后左右
        list.add(cur.val);
        preOrder(cur.left,list);
         preOrder(cur.right,list);
    }

中序遍历

public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list=new LinkedList<>();
        inOrder(root,list);
        return list; 
    }
    //参数的返回类型和参数
    public void inOrder(TreeNode root,List<Integer> list){
        //终止条件，当节点为空的之后直接返回
        if(root==null){
            return ;
        }
        //单层循环的条件：先左后中最后后
        inOrder(root.left,list);
        list.add(root.val);
        inOrder(root.right,list);

    }

后序遍历

public List<Integer> postorderTraversal(TreeNode root) {
       List<Integer> list=new LinkedList<>();
       postOrder(root,list);
       return list;

    }
    //返回值和需要的参数
    public void postOrder(TreeNode node,List<Integer> list){
        //终止条件
        if(node==null){
            return;
        }
        postOrder(node.left,list);
        postOrder(node.right,list);
        list.add(node.val);
    }
      

迭代遍历

迭代遍历，直接写的话也记不起来了，看一下解释

递归的实现：每一次递归调用把函数的局部变量，函数值，返回地址等压入调用栈中，递归返回时，从栈顶弹出上一次递归的各项参数，所以可以采用栈实现二叉树的遍历

不会写，感觉一点思路都不没有，不知道声明了栈之后，该干什么, 如果是循环的判断根节点不为空，然后将左右节点入栈的话，如何让左右节点出栈呢，这边可能会用到右节点先进，左节点后进

答案的思路：先让根节点入栈，然后根节点出栈，当根节点的左右节点不为空的时候，右左节点分别入栈，循环的条件是栈不为空

前序迭代法的实现

public List<Integer> preorderTraversal(TreeNode root) {
      
       List<Integer> list=new LinkedList<>();
       if(root==null){
           return list;
       }
       Stack<TreeNode> st=new Stack<>();//栈中存放的是节点
       st.push(root);
       while(!st.isEmpty()){
           TreeNode node=st.pop();
           list.add(node.val);
           if(node.right!=null){
               st.push(node.right);
           }
           if(node.left!=null){
               st.push(node.left);
           }
       }
       return list;
    }

感觉中序和后序遍历的迭代完全不是一个路子，因为此时的节点暂时不满足出栈的条件，但是又不知道什么时候该出栈

中序遍历的迭代法，能看懂，写不出来
后序遍历的迭代法，能看懂，写不出来

//中学遍历的迭代法
public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list=new LinkedList<>();
        if(root==null){
            return list;
        }
        Stack<TreeNode> st=new Stack<>();
        TreeNode cur=root;
        while(cur!=null || !st.isEmpty()){
            if(cur!=null){
                st.push(cur);
                cur=cur.left;
            }else{
                cur=st.pop();
                list.add(cur.val);
                cur=cur.right;
            }
        }
        return list;
    }

//后序遍历的迭代法
```java
public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.left != null){
                stack.push(node.left);
            }
            if (node.right != null){
                stack.push(node.right);
            }
        }
        Collections.reverse(result);
        return result;
    }