树的遍历及其应用

二叉树的遍历：

一、递归式遍历：

1.树的递归式遍历的顺序：

 

分析：从中我们可以看出每个节点都会被遍历到三遍

2.代码实现(包括树的结构)：

 /*
      * 树的基本结构定义
      */
    class Node {
        int val;
        Node left;
        Node right;
    }
    
    //树的递归式遍历：
    public static void orderTraver(Node t) {
        if (t == null) {
            return;
        }
        orderTraver(t.left);
        orderTraver(t.right);
    }

 

3.前中后序遍历(深度优先搜索)：

前置知识点：前中后序遍历概念

(1).前序遍历:对于任何一个子树，总是先遍历头节点，再遍历左子树，最后遍历右子树

(2).中序遍历:对于任何一个子树，总是先遍历左子树，再遍历头节点，最后遍历右子树

(3).后序遍历:对于任何一个子树，总是先遍历左子树，再遍历右子树，最后遍历头节点

 

在递归序遍历中实现前中序遍历的操作：

根据上述知识点已知递归序遍历会经历同一个节点3次
(1).前序遍历:在第1次遍历到节点时,执行所要进行的操作

代码：

//递归式前序遍历
    public static void preOrderTraver(Node t) {
        if (t == null) {
            return;
        }
        System.out.print(t.val + " ");//执行所对应的遍历操作
        preOrderTraver(t.left);
        preOrderTraver(t.right);
    }

 

(2).中序遍历:在第2次遍历到节点时,执行所要进行的操作

 代码：

//递归式中序遍历
    public static void inOrderTraver(Node t) {
        if (t == null) {
            return;
        }
        inOrderTraver(t.left);
        System.out.print(t.val + " ");//执行所对应的遍历操作
        inOrderTraver(t.right);
    }
    

 

(3).后序遍历:在第3次遍历到节点时,执行所要进行的操作

代码：

//递归式后序遍历
    public static void posOrderTraver(Node t) {
        if (t == null) {
            return;
        }
        posOrderTraver(t.left);
        posOrderTraver(t.right);
        System.out.print(t.val + " ");//执行所对应的遍历操作
    }

 

2.非递归遍历

(1).前序遍历(自己手动实现压栈):

* 预先准备:先把根节点压到栈中
* 1.从栈中弹出一个节点并输出
* 2.将这个节点的右儿子和左儿子先后压入栈中(如果存在的话)
* 重复以上2个步骤即可

public static void preOrderTraver1(Node head) {
        if (head == null) {
            return;
        }
        Stack<Node> sk = new Stack<>();
        sk.push(head);
        while (sk.size() > 0) {
            System.out.print(sk.peek().val + " ");
            Node t = sk.pop();
            if (t.right != null) {
                sk.push(t.right);
            }
            if (t.left != null) {
                sk.push(t.left);
            }
        }
        System.out.println();
    }

 

(2).中序遍历：

* 处理操作：
* 1.先把所在节点的左儿子(以及左儿子的左儿子(一直递推,直到找不到左儿子为止))弹入节点
* 2.之后陆续弹出这些节点,并在弹出的过程中寻找这些节点有没有右树,如果有右树,则对这颗右树继续执行1,2操作
* 不断执行以上的操作，直到栈空

public static void inOrderTraver1(Node head) {
        if (head == null) {
            return;
        }
        Stack<Node> sk = new Stack<>();
        while (sk.size() > 0 || head != null) {
            if (head != null) {//弹入该子树的所有左儿子(一定要把弹入左儿子的情况放if条件的前面)
                               //此处的if有点相当于while的作用,在head == null之前会一直往里弹
                sk.push(head);
                head = head.left;
            }
            else {//弹入右儿子(子树)一定是在这个子树的左儿子都弹完的情况下才进行的
                head = sk.pop();
                System.out.print(head.val + " ");
                head = head.right;//下一次循环还是先去看它有没有左儿子
            }
        }
        System.out.println();
    }

 

(3).后续遍历：

* 非递归实现后续遍历：
* 预先准备:设好两个栈,原栈和收集栈,并将根节点弹入到原栈中
* 1.将原栈中顶层节点取出,压入到收集栈中
* 2.把该节点的左节点和右节点依次压入到栈中
* 重复以上2个步骤,直至原栈为空后,再依次把收集栈中的元素全部取出,得到的节点顺序即为后续遍历结果
*
* 分析:(以下简称:左儿子->左,右儿子->右,头节点->头)
* 因为后续遍历是左右头的顺序,但是在非递归遍历时,不好跨过头节点去直接遍历左右儿子
* 所以我们可以将左右头看成头右左的翻转(可以用栈实现翻转,只要进栈顺序是头右左,则出栈顺序就是所要的左右头)
* 所以此时收集栈的进栈顺序是头右左,所以原栈的出栈顺序就是头右左
* 此时只要调整好原栈的进出栈操作即可(与先序遍历思想类似)
*

public static void posOrderTrever1(Node head) {
        Stack<Node> sk1 = new Stack<>();//原栈
        Stack<Node> sk2 = new Stack<>();//收集栈
        sk1.push(head);
        while (sk1.size() > 0) {
            Node t = sk1.pop();
            sk2.push(t);
            if (t.left != null) {
                sk1.push(t.left);
            }
            if (t.right != null) {
                sk1.push(t.right);
            }
        }
        while (sk2.size() > 0) {
            System.out.print(sk2.pop().val + " ");
        }
        System.out.println();
    }

 

将遍历的结果存储到线性表中：

//将某种顺序的遍历序列内容存到一个线性表中(使用辅助结构List)
    //以中序遍历为例：
    public static void inOrderResult(Node root,List<Node> list) {
        if (root == null) {
            return;
        }
        inOrderResult(root.left,list);
        list.add(root);
        inOrderResult(root.right,list);
    }

 

 

深度优先搜索的应用：
剑指 Offer 55 - I. 二叉树的深度 - 力扣（LeetCode） (leetcode-cn.com)

代码：

public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;
    }

 

 

3.广度(宽度)优先遍历：

* 二叉树的广度(宽度)优先遍历：
* 即按层级一层层往下遍历的方式
* 思路：用队列(先进先出的功能)进行维护,先进根节点,然后每次从队列中弹出一个节点
* 并分布弹入这个弹出节点的左节点和右节点即可.

public static void wideOrderTraver(Node head) {
        if (head == null) {
            return;
        }
        Queue<Node> q = new LinkedList<>();//双向链表即为队列
        q.add(head);
        while (q.size() > 0) {
            Node t = q.poll();
            System.out.print(t.val + " ");
            if (t.left != null) {
                q.add(t.left);
            }
            if (t.right != null) {
                q.add(t.right);
            }
        }
    }

 

4.广度(宽度)优先遍历的应用：

* 寻找一颗树的最大宽度(即求出哪一层的节点个数最多，返回那个层数的节点个数)

 

思路：用广度优先搜索，按层级顺序依次往下遍历，再遍历的过程中，要注意什么时候换层并对每一层做好统计和处理即可，使用哈希表来辅助实现

代码及解析：

public static int GetMaxWidth(Node head) {
        if (head == null) {
            return 0;
        }
        int max = Integer.MIN_VALUE;//用来存储最终的答案
        int curLevel = 1;//表示当前执行到哪个层了
        int curNodes = 0;//表示当前层次已有多少个节点
        Queue<Node> q = new LinkedList<>();
        HashMap<Node,Integer> hm = new HashMap<>();//记录节点所在的层数
        q.add(head);
        hm.put(head, 1);
        while (q.size() > 0) {
            Node t = q.poll();
            int NodeLevel = hm.get(t);
            if (NodeLevel == curLevel) {//还在当前层
                curNodes++;
            }
            else {
                max = Math.max(max, curNodes);//对上一层的总结点个数进行处理
                curLevel++;
                curNodes = 1;//注意此处是1,不要把这个节点给漏了
            }
            if (t.left != null) {
                q.add(t.left);
                hm.put(t.left, NodeLevel + 1);
            }
            if (t.right != null) {
                q.add(t.right);
                hm.put(t.right, NodeLevel + 1);
            }
        }
        return max;
    }