打印右侧节点数及最后一个左子树节点

Author: yangjunbao

src/com/apptao/leetcode/tree/AverageOfLevelsInBinaryTree.java

@@ -0,0 +1,99 @@
+package com.apptao.leetcode.tree;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * Created by a on 2017-12-28.
+ *
+ * 给出一个二叉树，求出每一层的 数据和 平均数，
+ * 例如：
+ * Input:
+ 3
+ / \
+ 9  20
+ /  \
+ 15   7
+ Output: [3, 14.5, 11]
+ 第一层级 为 3/1=3
+ 第二层级 为 29/2=14.5
+ 第三层级 为 22/2=11
+ *
+ *
+ * 构建TreeNode  com.apptao.leetcode.tree.TreeNode;
+ */
+public class AverageOfLevelsInBinaryTree {
+
+    /**
+     * 统计同一层级的节点。
+     */
+    class LevelNode {
+        int level;
+        TreeNode node;
+        LevelNode(int level, TreeNode node){
+            this.level = level;
+            this.node = node;
+        }
+    }
+
+    public static void main(String[] args) {
+
+        AverageOfLevelsInBinaryTree averageOfLevelsInBinaryTree = new AverageOfLevelsInBinaryTree();
+        TreeNode root = new TreeNode(3);
+        TreeNode node1 = new TreeNode(9);
+        TreeNode node2 = new TreeNode(20);
+        TreeNode node3 = new TreeNode(15);
+        TreeNode node4 = new TreeNode(7);
+        root.rightChild = node1;
+        root.leftChild = node2;
+        root.rightChild.leftChild = node3;
+        root.leftChild.rightChild = node4;
+
+
+        List<Double> doubles = averageOfLevelsInBinaryTree.averageOfLevels(root);
+
+        System.out.println(doubles.toString());
+
+
+    }
+
+
+    /**
+     * 主要算法，隊列存取。
+     * @param root treeNode
+     * @return
+     */
+    public List<Double> averageOfLevels(TreeNode root) {
+        Queue<LevelNode> queue = new ArrayDeque<>();
+        LevelNode node = new LevelNode(0, root);
+        queue.offer(node);
+        int curLevel = 0, count = 0;
+        long sum = 0L;
+        List<Double> result = new ArrayList<>();
+        while(!queue.isEmpty()){
+            LevelNode first = queue.poll();
+            if(first.level == curLevel){
+                sum += first.node.val;
+                count++;
+            } else{
+                result.add((double)sum/count);
+                sum = first.node.val;
+                count = 1;
+                curLevel++;
+            }
+            if(first.node.leftChild != null){
+                queue.offer(new LevelNode(curLevel + 1, first.node.leftChild));
+            } if(first.node.rightChild != null){
+                queue.offer(new LevelNode(curLevel + 1, first.node.rightChild));
+            }
+        }
+        result.add((double)sum/count);
+        return result;
+    }
+
+
+
+
+}

src/com/apptao/leetcode/tree/BinaryTreeRightSideView.java

@@ -0,0 +1,118 @@
+package com.apptao.leetcode.tree;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Created by a on 2017-12-28.
+ *
+ * 给定一个二叉树，假设你站在右侧，打印出你能看到的路径内的节点。
+ * 右侧节点
+ * * 1            <---
+ * /   \
+ * 2     3         <---
+ * \     \
+ * 5     4       <---
+ *       /
+  *     6
+ * return [1, 3, 4].
+ */
+public class BinaryTreeRightSideView {
+
+    private int maxHeigh = Integer.MIN_VALUE;
+    List<Integer> list = new ArrayList<>();
+
+
+    public static void main(String[] args) {
+
+        BinaryTreeRightSideView averageOfLevelsInBinaryTree = new BinaryTreeRightSideView();
+        TreeNode root = new TreeNode(1);
+        TreeNode node1 = new TreeNode(2);
+        TreeNode node2 = new TreeNode(3);
+        TreeNode node3 = new TreeNode(4);
+        TreeNode node4 = new TreeNode(5);
+        TreeNode node6 = new TreeNode(6);
+        TreeNode node7 = new TreeNode(7);
+        root.leftChild = node1;
+        root.rightChild = node2;
+        root.leftChild.rightChild = node3;
+        root.rightChild.rightChild = node4;
+        root.rightChild.rightChild.leftChild = node6;
+//        root.rightChild.rightChild.rightChild = node7;
+
+
+        List<Integer> integers = averageOfLevelsInBinaryTree.rightSideView(root);
+
+        System.out.println(integers.toString());
+
+        List<Integer> integers1 = averageOfLevelsInBinaryTree.rightSideViewWihle(root);
+
+        System.out.println(integers1.toString());
+
+
+    }
+
+
+
+
+    public List<Integer> rightSideView(TreeNode root) {
+        if (root == null) return list;
+        dfs(root, 0);
+        return list;
+    }
+
+
+    /**
+     * 方案一：递归，
+     *
+     * @param node
+     * @param height
+     */
+    private void dfs(TreeNode node, int height) {
+        if (node != null) {
+            if (height > maxHeigh) {
+                list.add(node.val);
+                maxHeigh = height;
+            }
+            dfs(node.rightChild, height + 1);
+            dfs(node.leftChild, height + 1);
+        }
+    }
+
+    public List<Integer> rightSideViewWihle(TreeNode root) {
+        List<Integer> ans = new ArrayList<Integer>();
+        if (root == null) return ans;
+
+        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
+        queue.add(root);
+        queue.add(null);
+
+        while (!queue.isEmpty()) {
+            TreeNode node = queue.pollFirst();
+
+            if (node == null) {
+                if (queue.isEmpty()) {
+                    break;
+                } else {
+                    queue.add(null);
+                }
+            } else {
+                // add the rightest to the answer
+                if (queue.peek() == null) {
+                    ans.add(node.val);
+                }
+
+                if (node.leftChild != null) {
+                    queue.add(node.leftChild);
+                }
+                if (node.rightChild != null) {
+                    queue.add(node.rightChild);
+                }
+            }
+        }
+
+        return ans;
+    }
+
+}

src/com/apptao/leetcode/tree/TreeNode.java

@@ -0,0 +1,15 @@
+package com.apptao.leetcode.tree;
+
+/**
+ * 构建一个 节点为 int 类型节点
+ */
+public class TreeNode {
+        int val;
+        TreeNode leftChild;
+        TreeNode rightChild;
+
+        TreeNode(int x) {
+            val = x;
+        }
+
+}