数据结构与算法——Java实现 28.二叉树的锯齿形层序遍历

努力成为你想要成为的那种人，去奔赴你想要的生活

                                                                        —— 24.10.4

103. 二叉树的锯齿形层序遍历

给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[20,9],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

思路——双端队列实现

每一层的队列添加顺序不一样，根据层数进行判断，如果是奇数层从左到右遍历，从队列尾部添加，如果是偶数层，从右向左遍历，从队列首部添加，定义每一层的节点数和每一层的层数，进行迭代

---

LinkedListQueue

import java.util.Iterator;

// 用泛型好处：1.用null代表特殊值   2.代表更多类型
public class LinkedListQueue<E>
        implements Queue<E>,Iterable<E> {

    // 静态内部结点类
    private static class Node<E>{
        E value;
        Node<E> next;

        public Node(E value, Node<E> next){
            this.value = value;
            this.next = next;
        }
    }

    // 定义队列的头结点和尾节点
    Node<E> head = new Node<>(null,null);
    Node<E> tail = head;
    private int size = 0; // 节点数
    private int capacity = 10; // 容量

    public LinkedListQueue(int capacity) {
        this.capacity = capacity;
        tail.next = head;
    }

    public LinkedListQueue() {
        tail.next = head;
    }

    /*
        队列插入方法，在尾部插入
        Params:value-待插入值
        Returns：插入成功返回true，插入失败返回false
     */
    @Override
    public boolean offer(E e) {
        if(isFull()){
            return false;
        }
        Node<E> newNode = new Node<>(e,head);
        tail.next = newNode;
        tail = newNode;
        size++;
        return true;
    }

    /*
        从队头获取值，并移除
        Returns：如果队列非空返回队头值，否则返回null
     */
    @Override
    public E poll() {
        if (isEmpty()){
            return null;
        }
        Node<E> first = head.next;
        head.next = first.next;
        if (first == tail){
            tail = head;
        }
        size--;
        return first.value;
    }

    /*
        从队列头获取值，不移除
        Returns：如果队列非空返回队头值，否则返回null
    */
    @Override
    public E peek() {
        if(isEmpty()){
            return null;
        }
        return head.next.value;
    }

    /*
        检查队列是否为空
        Return：空返回true，否则返回false
    */
    @Override
    public boolean isEmpty() {
        return head == tail;
    }

    /*
        检查队列是否为满
        Return：满返回true，否则返回false
    */
    @Override
    public boolean isFull() {
        return size == capacity;
    }

    // 队列遍历方法 迭代器
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            Node<E> current = head.next;
            @Override
            public boolean hasNext() {
                return current != head;
            }

            @Override
            public E next() {
                E value = current.value;
                current = current.next;
                return value;
            }
        };
    }
}

---

TreeNode

public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;


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

    public TreeNode(int val, TreeNode left, TreeNode right) {
        this.left = left;
        this.val = val;
        this.right = right;
    }

    @Override
    public String toString() {
        return String.valueOf(this.val);
    }
}

---

 锯齿形层序遍历

import Day10Queue.LinkedListQueue;
import Day10Queue.TreeNode;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LeetCode103ZiazagForEach {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        LinkedListQueue<TreeNode> queue = new LinkedListQueue<>();
        queue.offer(root);
        int c1 = 1; // 当前层节点数
        boolean odd = true; // 奇数层
        while (!queue.isEmpty()) {
            LinkedList<Integer> level = new LinkedList<>(); // 保存每一层的结果
            int c2= 0; // 下一层节点数
            for (int i = 0; i < c1; i++) {
                TreeNode n = queue.poll();
                if (odd){
                    level.offerLast(n.val);
                }else{
                    level.offerFirst(n.val);
                }
                if (n.left != null) {
                    queue.offer(n.left);
                    c2++;
                }
                if (n.right != null) {
                    queue.offer(n.right);
                    c2++;
                }
            }
            odd = !odd;
            res.add(level);
            c1 = c2;
        }
        return res;
    }

    public static void main(String[] args) {
        /*
              1
            /   \
           2     5
          / \   / \
         3   4 6   7
       */
        TreeNode root = new TreeNode(1,
                new TreeNode(
                        2,new TreeNode(3),
                        new TreeNode(4)),
                new TreeNode(
                        5,new TreeNode(6),
                        new TreeNode(7)));
        List<List<Integer>> lists = new LeetCode103ZiazagForEach().zigzagLevelOrder(root);
        for (List<Integer> list : lists) {
            System.out.println(list);
        }
    }


}

---

力扣题解 

/**
 * 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<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> ans = new LinkedList<List<Integer>>();
        if (root == null) {
            return ans;
        }

        Queue<TreeNode> nodeQueue = new ArrayDeque<TreeNode>();
        nodeQueue.offer(root);
        boolean isOrderLeft = true;

        while (!nodeQueue.isEmpty()) {
            Deque<Integer> levelList = new LinkedList<Integer>();
            int size = nodeQueue.size();
            for (int i = 0; i < size; ++i) {
                TreeNode curNode = nodeQueue.poll();
                if (isOrderLeft) {
                    levelList.offerLast(curNode.val);
                } else {
                    levelList.offerFirst(curNode.val);
                }
                if (curNode.left != null) {
                    nodeQueue.offer(curNode.left);
                }
                if (curNode.right != null) {
                    nodeQueue.offer(curNode.right);
                }
            }
            ans.add(new LinkedList<Integer>(levelList));
            isOrderLeft = !isOrderLeft;
        }
        return ans;
    }
}