算法练习 Day14 | leetcode 144.二叉树的前序遍历，94.二叉树的中序遍历，145.二叉树的后序遍历

一、基础知识

代码随想录链接

二、算法题

1.递归遍历

144.二叉树的前序遍历

题目链接

/**
 * 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> res=new LinkedList<>();
        preorder(root, res);
        return res;
    }

    public void preorder(TreeNode root,List res){
        if(root==null){
            return;
        }
        res.add(root.val);
        preorder(root.left, res);
        preorder(root.right, res);
    }
}

List、LinkedList、ArrayList

• List 是集合列表接口，ArrayList 和 LinkedList 是 List 接口的实现类
  • ArrayList 是动态数组顺序表，顺序表的存储地址是连续的，所以查找比较快，但是插入和删除时由于需要把其它的元素顺序移动，所以比较耗时。
  • LinkedList 是双向链表的数据结构，同时实现了双端队列 Deque 接口，链表节点的存储地址是不连续的，每个存储地址通过指针关联，在查找时需要进行指针遍历节点，所以查找比较慢，而在插入和删除时比较快
• ArrayList和LinkedList的区别
  • ArrayList底层的数据结构是数组
  • LinkedList底层的数据结构是双向链表

94.二叉树的中序遍历

题目链接

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        inorder(root, res);
        return res;
    }

    public void inorder(TreeNode root,List res){
        if(root==null){
            return ;
        }
        inorder(root.left, res);
        res.add(root.val);
        inorder(root.right, res);
    }
}

145.二叉树的后序遍历

题目链接 

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        postorder(root,res);
        return res;
    }
    public void postorder(TreeNode root,List res){
        if(root==null){
            return;
        }
        postorder(root.left, res);
        postorder(root.right, res);
        res.add(root.val);
    }
}

2.迭代遍历

 144.二叉树的前序遍历

题目链接

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        //迭代法，用栈实现
        List<Integer> res=new ArrayList<>();
        if(root==null){
            return res;
        }
        Stack<TreeNode> stack=new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            //专门新建一个结点保存栈弹出的元素是因为我们要根据这个被弹出的元素，找到这个元素接下来的左右结点，而不是用root.left，root.right来操作
            TreeNode tmp=stack.pop();
            res.add(tmp.val);
            //要先加入右节点再加入左节点，这样到时候先弹出的是左节点
            if(tmp.right!=null){
                stack.push(tmp.right);
            }
            if(tmp.left!=null){
                stack.push(tmp.left);
            }
        }
        return res;
    }
}

前序遍历（迭代法）

• 注意把元素加入到栈中时，左右结点先加右节点再加左节点，这样弹出的时候先弹出左节点 

 94.二叉树的中序遍历

题目链接

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<>();
        if(root==null){
            return res;
        }
        Stack<TreeNode> stack=new Stack<>();
        TreeNode cur=root;
        while(cur!=null||!stack.isEmpty()){
            if(cur!=null){
                stack.push(cur);
                cur=cur.left;
            }
            else{
                TreeNode tmp=stack.pop();
                res.add(tmp.val);
                cur=tmp.right;
            }
        }
        return res;
    }
}

• 前序遍历的顺序是中左右，先访问的元素是中间节点，要处理的元素也是中间节点，要访问的元素和要处理的元素顺序是一致的，都是中间节点。
• 中序遍历的遍历顺序是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点，造成了处理顺序和访问顺序是不一致的。
• 所以在使用迭代法写中序遍历，需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。

不是很懂

 145.二叉树的后序遍历

题目链接 

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        //迭代法
        List<Integer> res=new ArrayList<>();
        if(root==null){
            return res;
        }
        Stack<TreeNode> stack=new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode tmp=stack.pop();
            res.add(tmp.val);
            if(tmp.left!=null){
                stack.push(tmp.left);
            }
            if(tmp.right!=null){
                stack.push(tmp.right);
            }
        }
        Collections.reverse(res);
        return res;
    }
}

思路：

• 跟前序遍历一样，但是改变了左右节点的加入顺序，并在最后对列表进行翻转
• 加入栈的顺序：中—>左—>右
• 弹出栈在列表中保存值的顺序：中—>右—>左
• 翻转之后列表中的值：左—>右—>中

Collections.reverse(res)

• Collections类是一个实用类，提供了一系列静态方法用于操作列表集合。其中一个方法是reverse()，用于反转集合中元素的顺序。

 

3.统一迭代法

还没写