层序遍历二叉树代码

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

/*
 * 层序遍历二叉树
 * 创建一个二叉树：
 *                             23
 *                           /    \
 *                          34     21
 *                        /       /   \
 *                       99       45   60
 *                      /  \
 *                     77   90
 * */

public class Suanfa4 {
    public static class TreeNode<E>  {
         Integer value;        //节点的值
         TreeNode node;        //此节点，数据类型为Node
         TreeNode left;        //此节点的左子节点，数据类型为Node
         TreeNode right;       //此节点的右子节点，数据类型为Node

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }

        public TreeNode getNode() {
            return node;
        }

        public void setNode(TreeNode node) {
            this.node = node;
        }

        public TreeNode getLeft() {
            return left;
        }

        public void setLeft(TreeNode left) {
            this.left = left;
        }

        public TreeNode getRight() {
            return right;
        }

        public void setRight(TreeNode right) {
            this.right = right;
        }

        public TreeNode(Integer value) {
            this.value=value;
            this.left=null;
            this.right=null;
        }
        public String toString() {         //自定义的toString方法，为了方便之后的输出
            return this.value+" ";
        }
    }
//这个算法用到了队列。解释一下队列：
/*
 * |它的API|抛出异常  |返回true.false|阻塞  |超时
 * |插入   |add(e)   |offer(e)      |put(e)|offer(e,time,unit)
 * |移除   |remove() |poll()       |take()|poll(time,unit)
 * |检查   |element()|peek()      |无    |无
 * add:当队列满时，抛出异常；
 * remove:当队列空时，抛出异常；
 * offer：插入失败，返回false
 * poll:队列是空，返回null;否则返回对象
 * put:队列是满时，阻塞。等空了，才能放入
 * take:队列是空时，阻塞等。
 * offer(e,time,unit)：超时时间过了，返回false
*/
    /*思路：
    1、需要一个数组存放最终结果值
    2、需要一个临时数组存放每层结果值
    3、需要一个队列来存放树的TreeNode节点
     */
        public List<List<Integer>> levelOrder(TreeNode root) {
            List<List<Integer>> res = new ArrayList<>(); // 定义一个数组存放结果
            if (root == null) {
                return res;
            }

            Queue<TreeNode> queue = new LinkedList<>(); //队列，队列的特点还记得吗？和栈的区别？队列：先进先出，栈：后进先出
            queue.offer(root);//树的根节点插入到队列
            while (!queue.isEmpty()) {//队列里只要不是空，我就循环啊。遇到while代码就一定有next的指向代码，如果for它是自身就带next指向。while比for更灵活。
                int size = queue.size(); //队列长度
                List<Integer> list = new ArrayList<>(); //定义一个存放层元素的临时数组，这就是每一层新增的数组

                while (size-- > 0) { //size--是循环next的指向代码，这里size是每一层元素的大小，当左右节点都存在的时候，size是2,就会循环2次。每次循环，都是把层所有的元素插入队列中，所以这个循环是遍历当前层里的元素
                    TreeNode node = queue.poll(); //当前节点弹出队列
                    //第一轮，第二层元素34，21
                    //第二轮，第三层元素99       45   60
                    //第三轮，第四层元素  77   90
                    list.add(node.value); //并把当前节点值放入结果数组，size2的时候，2次add到数组里。

                    if (node.left != null) {
                        queue.offer(node.left); //当前节点的左节点插入队列
                    }
                    if (node.right != null) {
                        queue.offer(node.right); //当前节点的右节点插入队列
                    }
                }

                res.add(list);
            }

            return res;
        }


}

 

import java.util.Arrays;
import java.util.List;

public class SuanfaMain {
    public static void main(String[] args) {
//1
        int a[] = { 49, 35, 65, 97, 76, 13, 27, 49 };
        int[] rs=new Suanfa1().twoSum(a,100);
        System.out.println(Arrays.toString(rs));
//2
        Suanfa2.ListNode a1=new Suanfa2.ListNode(2);
        Suanfa2.ListNode a2=new Suanfa2.ListNode(4);
        Suanfa2.ListNode a3=new Suanfa2.ListNode(3);

        a1.next=a2;
        a2.next=a3;

        Suanfa2.ListNode b1=new Suanfa2.ListNode(5);
        Suanfa2.ListNode b2=new Suanfa2.ListNode(6);
        Suanfa2.ListNode b3=new Suanfa2.ListNode(4);

        b1.next=b2;
        b2.next=b3;

        Suanfa2.ListNode c1=new Suanfa2().addTwoNumbers(a1,b1);

        System.out.println(c1.val+""+c1.next.val+""+c1.next.next.val);
        //3
        Suanfa3 suanfa3=new Suanfa3();
        int x=suanfa3.lengthOfLongestSubstring("abcdeadfgy");
        System.out.println(x);

        //4
        Suanfa4.TreeNode<Integer> root=new Suanfa4.TreeNode<>(23);
        Suanfa4.TreeNode<Integer> node1=new Suanfa4.TreeNode<>(34);
        Suanfa4.TreeNode<Integer> node2=new Suanfa4.TreeNode<>(21);
        Suanfa4.TreeNode<Integer> node3=new Suanfa4.TreeNode<>(99);
        Suanfa4.TreeNode<Integer> node4=new Suanfa4.TreeNode<>(77);
        Suanfa4.TreeNode<Integer> node5=new Suanfa4.TreeNode<>(90);
        Suanfa4.TreeNode<Integer> node6=new Suanfa4.TreeNode<>(45);
        Suanfa4.TreeNode<Integer> node7=new Suanfa4.TreeNode<>(60);
        root.left=node1;
        root.right=node2;
        node1.left=node3;
        node3.left=node4;
        node3.right=node5;
        node2.left=node6;
        node2.right=node7;

        List<List<Integer>> suanfa4 =new Suanfa4().levelOrder(root);
        System.out.println(suanfa4);
    }
}