树-树的遍历(DFS、BFS、先序、中序、后序)

树的遍历方式

树的遍历方式总体分为两类:深度优先搜索(DFS)、广度优先搜索(BFS),其实这两种方式主要是图的遍历方式,但是树可以被抽象为简单的图,所以这两种方式也可以作为树的遍历方式。

  • 常见的DFS:先序遍历、中序遍历、后序遍历
  • 常见的BFS:层序遍历(按层遍历)
    树-树的遍历(DFS、BFS、先序、中序、后序)_第1张图片

深度优先搜索

深度优先搜索(DFS)简单来说就是沿着每一个分支路径遍历直到不能再深入为止,也就是到达了叶节点。如果到达叶节点,那我们就向上回溯,回到叶节点之前的那一个节点,接着遍历该节点未被访问过的子节点。一直重复这个过程直到所有的节点把遍历完。

以上图为例,我们走一下整体的遍历流程:

  • 首先访问A节点,接着我们访问A的子节点B节点
  • B节点访问之后,我们在访问B的子节点D节点
  • D节点没有子节点,所以我们向上回溯,访问B节点
  • 发现B节点的的子节点E未被访问,那么我们访问E节点
  • E节点有子节点I节点,我们访问E节点的子节点I
  • I节点为叶节点,没有子节点,所以我们向上回溯到E节点
  • E节点的所有节点都被访问过了,继续回溯到上一个节点B
  • B节点的所有子节点也都被访问过了,继续回溯到A节点,发现A的子节点C未被访问,访问C
  • 重复上述过程,知道所有的节点被访问…

实现这个过程的时候有一个关键点,我们可以设置一个visited[]数组,长度为节点的个数,初始值为0,如果被访问了将其对应下标位置的visited[index]设置为1,防止重复访问,陷入死循环。

实现方式

深度优先搜索(DFS)的实现方式主要有两种:

  1. 递归实现
  2. 迭代实现(依靠栈数据结构)

递归实现

/*
此处的返回值并没有什么含义,大家可以根据自己的需求自行修改,代码是根据下面所示的二叉树写的。
*/
   3
   / \
  9  20
    /  \
   15   7
public int depthTraversal(TreeNode root)
 {
      if(root == null) return -1;
      System.out.print(root.val + " ");
      depthTraversal(root.left);
      depthTraversal(root.right);
      return 0;

  }
运行结果:3 9 20 15 7 

迭代实现

首先我们要知道栈这种数据结构是先进后出,所以我们入栈的时候要先压入最右的节点,然后依次从右往左压入节点,这样就能保证出栈的时候首先访问左节点。
具体的步骤如下:

  1. 首先我们将节点A压入栈中,stack(A)
  2. 然后我们将A出栈,同时将A的子节点从右到左压入栈中,此时B在栈的顶部,stack(B,C)
  3. 然后将B节点弹出,同时将B的子节点E,D压入栈中,此时D在栈的顶部,stack(D,E,C)
  4. 然后将D节点弹出,没有子节点压入,此时E在栈的顶部,stack(E,C)
  5. 然后将E节点弹出,同时将E的子节点I压入,stack(I,C)
  6. 重复上述过程,直到栈空,最终遍历完成
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/

public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> lists=new ArrayList<Integer>();
        if(root==null)
            return lists;
        Stack<TreeNode> stack=new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode tree=stack.pop();      //先往栈中压入右节点,再压左节点,这样出栈就是先左节点后右节点了。
            if(tree.right!=null)
                stack.push(tree.right);
            if(tree.left!=null)
                stack.push(tree.left);
            lists.add(tree.val);
        }
        return lists;
    }
}
    3
   / \
  9  20
    /  \
   15   7
结果:3 9 20 15 7 

广度优先搜索

广度优先搜索就是层序遍历,顾名思义就是按照树的层次结构一层一层遍历,访问完一层我们就进入下一层,且每个节点只能访问一遍。上图按照广度优先搜索方式的结果为:A,B,C,D,E,F,G,H,I(假设每层节点从左到右访问)。

实现方式

广度优先搜索的实现方式主要有两种:

  1. 递归实现
  2. 迭代实现(依靠队列数据结构)

递归实现

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

    private void BFS(TreeNode root, int level) {
        //递归终止条件
        if (root == null) {
            return;
        }
        if (level >= res.size()) {
            //如果是新的一层,就创建
            res.add(new ArrayList<>());
        }
        //添加当前的元素
        res.get(level).add(root.val);
        //遍历左节点
        DFS(root.left, level + 1);
        //遍历又节点
        DFS(root.right, level + 1);
    }
}

广度优先搜索使用递归的方式较为繁琐,可以直接使用迭代的方式。

迭代实现

通过迭代实现树的层序遍历,需要借助数据结构队列先进先出的特性。我们以上图为例进行分析。
具体实现步骤
我们通过数组res[]来保存出队的元素

  • 首先将节点A插入队列,队列中有元素A,queue(A)
  • 接着将A出队,将A存入数组,同时将A的左右节点依次插入队列,queue(B,C)
  • 然后将B出队,存入数组,同时将B的左右节点依次插入队列,queue(C,D,E)
  • 然后将C出队,存入数组,同时将C的左右子节点依次插入队列,queue(D,E,F,G,H)
  • 重复上述过程,直到队列为空,res中保存了树层序遍历的结果。
public List<Integer> levelOrder(TreeNode root) {
        Queue<TreeNode > queue = new LinkedList<>();
        List<Integer> res = new ArrayList<>();
        if(root == null) return res;
        queue.add(root);
        while (!queue.isEmpty())
        {
            ListNode node = queue.poll();
            res.add(node.val);
            if(node.left != null) queue.add(node.left);
            if(node.right != null) queue.add(node.right);
            
        }
        return res;
    }

你可能感兴趣的:(数据结构与算法,深度优先,数据结构,算法)