二叉树的遍历

@

目录

• 一、深度优先遍历二叉树
  • 1.前序遍历
    • 1.1.递归遍历
      • • 1.1.1.思路
        • 1.1.2.代码
    • 1.2.迭代遍历
      • • 1.2.1.思路
        • 1.2.2.代码
  • 2.中序遍历
    • 2.1.递归遍历
      • • 2.1.1.思路
        • 2.1.2.代码
    • 2.2.迭代遍历
      • • 2.2.1.思路
        • 2.2.2.代码
  • 3.后序遍历
    • 3.1.递归遍历
      • • 3.1.1.思路
        • 3.1.2.代码
    • 3.2.迭代遍历
      • • 3.2.1.思路
        • 3.2.2.代码
  • 二、广度优先遍历二叉树
    • 1.层序遍历
      • • 1.1思路
        • 1.2代码

一、深度优先遍历二叉树

1.前序遍历

1.1.递归遍历

1.1.1.思路

1.1.2.代码

//递归 二叉树的前序遍历
import java.util.LinkedList;
import java.util.List;

class Solution2 {
    //定义一个链表用来接收答案
    LinkedList<Integer> list = new LinkedList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        //考虑特殊情况
        if(root==null)return list;
        list.add(root.val);
        //如果左边不为空就先对左边进行深度优先查询
        if (root.left != null) {
            DFS(root.left);
        }
        if (root.right != null) {
            DFS(root.right);
        }
        return list;
    }
    //1\首先处理传入的值
    //2\在进行下一步判断和调用递归
    public void DFS(TreeNode node) {
        list.add(node.val);
        if (node.left!= null) {
            DFS(node.left);
        }
        if (node.right != null) {
            DFS(node.right);
        }
    }
}

1.2.迭代遍历

1.2.1.思路

1.2.2.代码

//不用递归,而是用迭代查询

import java.util.*;

class Solution1 {
    //定义一个栈(stack已经过时,而deque是stack的升级版),用来存储节点,目的是可以返回上一个节点
    //定义一个链表,用来存储节点的值,最后的答案
    public List<Integer> preorderTraversal(TreeNode root) {
        LinkedList<Integer> list=new LinkedList<>();
        //特殊情况
        if(root==null)return list;
        Deque<TreeNode> stack=new LinkedList<>();
        stack.push(root);
        TreeNode node=root;
        //这里是重点,如果node是空,则将栈中节点推出,返回上一个节点
        //如果node非空,则推入栈中方便返回上一个节点,继续向左边遍历
        while(!stack.isEmpty()){
            while(node!=null){
                list.add(node.val);
                stack.push(node);
                node=node.left;
            }
            node=stack.pop();
            node=node.right;
        }
        return list;
    }
}

---

2.中序遍历

2.1.递归遍历

2.1.1.思路

2.1.2.代码

class Solution3 {
    public List<Integer> inorderTraversal(TreeNode root) {
        LinkedList<Integer> list = new LinkedList<>();
        if (root == null) return list;
        if (root.left != null) {
            DFS(root.left, list);
        }
        list.add(root.val);
        if (root.right != null) {
            DFS(root.right, list);
        }
        return list;
    }
    private void DFS(TreeNode node, LinkedList<Integer> list) {
        if (node.left != null) {
            DFS(node.left, list);
        }
        list.add(node.val);
        if (node.right != null) {
            DFS(node.right, list);
        }
    }
}

2.2.迭代遍历

2.2.1.思路

2.2.2.代码

3.后序遍历

3.1.递归遍历

3.1.1.思路

3.1.2.代码

点击查看代码

//后续遍历，递归
import java.util.LinkedList;
import java.util.List;

class Solution4 {
    public List<Integer> postorderTraversal(TreeNode root) {
        LinkedList<Integer> list=new LinkedList<>();
        if(root==null)return list;
        if(root.left!=null)DFS(root.left,list);
        if(root.right!=null)DFS(root.right,list);
        list.add(root.val);
        return list;
    }
    private void DFS(TreeNode node,List<Integer> list){
        if(node.left!=null)DFS(node.left,list);
        if(node.right!=null)DFS(node.right,list);
        list.add(node.val);
    }
}

3.2.迭代遍历

3.2.1.思路

//后续遍历，递归
import java.util.LinkedList;
import java.util.List;

class Solution4 {
    public List<Integer> postorderTraversal(TreeNode root) {
        LinkedList<Integer> list=new LinkedList<>();
        if(root==null)return list;
        if(root.left!=null)DFS(root.left,list);
        if(root.right!=null)DFS(root.right,list);
        list.add(root.val);
        return list;
    }
    private void DFS(TreeNode node,List<Integer> list){
        if(node.left!=null)DFS(node.left,list);
        if(node.right!=null)DFS(node.right,list);
        list.add(node.val);
    }
}

3.2.2.代码

二、广度优先遍历二叉树

1.层序遍历

1.1思路

1.2代码

点击查看代码

//二叉树的层序遍历
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

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 Solution2 {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        LinkedList<List<Integer>> answer = new LinkedList<>();
        if (root == null) return answer;
        queue.add(root);

        LinkedList<Integer> rootlist = new LinkedList<Integer>();
        rootlist.add(root.val);
        answer.add(rootlist);

        while (!queue.isEmpty()) {
//            LinkedList<Integer> list=new LinkedList<>();
//            while(!queue.isEmpty()) {1
//                node = queue.poll();
//                if (node.left != null) {
//                    list.add(node.left.val);
//                }
//                if (node.right != null) {
//                    list.add(node.right.val);
//                }
//                queue.add(node.left);
//                queue.add(node.right);
//                if (!list.isEmpty()) answer.add(list);
//
//            }
//遇到的问题：如何让一个list添加一层的节点的值而不是一个节点下面的两个节点的值的值？
            LinkedList<Integer> list = new LinkedList<>();
//可以利用queue.size，指定一个size次的for循环，这样poll()出去的节点就是上一层的所有节点
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    list.add(node.left.val);
                    queue.add(node.left);
                }
                if (node.right != null) {
                    list.add(node.right.val);
                    queue.add(node.right);
                }
            }
//而list内的值也是当前层的值
            if (!list.isEmpty()) answer.add(list);
//一次for之后，queue里面的节点是当前层的节点，因为上一层的size个节点已经被poll()出去了
        }
        return answer;
    }
}

相关练习可以在LeetCode上面找到