From fe407e593b10e0ac91e802339c0f975998860277 Mon Sep 17 00:00:00 2001 From: passer <1227118745@qq.com> Date: Wed, 20 Mar 2019 17:24:36 +0800 Subject: [PATCH 1/4] Commit solution of leetcode 102 problem --- xdu/passer/Java/passer_102.md | 56 +++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 xdu/passer/Java/passer_102.md diff --git a/xdu/passer/Java/passer_102.md b/xdu/passer/Java/passer_102.md new file mode 100644 index 0000000..2024a96 --- /dev/null +++ b/xdu/passer/Java/passer_102.md @@ -0,0 +1,56 @@ +Problem: +--- +### Binary Tree Level Order Traversal +Given a binary tree, return the level order traversal of its nodes' values. +(ie, from left to right, level by level). + +For example: +Given binary tree +[3,9,20,null,null,15,7] +  3 +  /  \ + 9 20 +   /   \ +   15  7 +return its level order traversal as: +[ + [3], + [9,20], + [15,7] +] + +Code: +--- +``` +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode(int x) { val = x; } + * } + */ +class Solution { + List> listAll = new ArrayList<>(); + public List> levelOrder(TreeNode root) { + levelOrder(root,0); + return listAll; + } + + public void levelOrder(TreeNode root,int depth){ + if(root == null) return; + List list = null; + if(depth == listAll.size()) { + list = new ArrayList<>(); + listAll.add(list); + } + else { + list = listAll.get(depth); + } + list.add(root.val); + levelOrder(root.left,depth + 1); + levelOrder(root.right,depth + 1); + } +} +``` From 79975773fb6d4778e7cf2e60d24b3df8a9cddae4 Mon Sep 17 00:00:00 2001 From: passer <1227118745@qq.com> Date: Wed, 20 Mar 2019 20:21:34 +0800 Subject: [PATCH 2/4] commit first --- xdu/passer/Java/passer_102.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/xdu/passer/Java/passer_102.md b/xdu/passer/Java/passer_102.md index 2024a96..00c0c32 100644 --- a/xdu/passer/Java/passer_102.md +++ b/xdu/passer/Java/passer_102.md @@ -2,7 +2,7 @@ Problem: --- ### Binary Tree Level Order Traversal Given a binary tree, return the level order traversal of its nodes' values. -(ie, from left to right, level by level). +(ie: from left to right, level by level). For example: Given binary tree From be1e2db629a7d1903ab6380f28deb21ff368c782 Mon Sep 17 00:00:00 2001 From: passer <1227118745@qq.com> Date: Wed, 20 Mar 2019 20:49:58 +0800 Subject: [PATCH 3/4] modify .md to .java --- xdu/passer/Java/passer_102.java | 61 +++++++++++++++++++++++++++++++++ xdu/passer/Java/passer_102.md | 56 ------------------------------ 2 files changed, 61 insertions(+), 56 deletions(-) create mode 100644 xdu/passer/Java/passer_102.java delete mode 100644 xdu/passer/Java/passer_102.md diff --git a/xdu/passer/Java/passer_102.java b/xdu/passer/Java/passer_102.java new file mode 100644 index 0000000..516dfba --- /dev/null +++ b/xdu/passer/Java/passer_102.java @@ -0,0 +1,61 @@ +package com.passer._0320; +/* + Problem:Binary Tree Level Order Traversal + + Given a binary tree, return the level order traversal of its nodes' values. + (ie: from left to right, level by level). + For example: + Given binary tree + [3,9,20,null,null,15,7] + 3 + / \ + 9 20 + / \ + 15 7 + return its level order traversal as: + [ + [3], + [9,20], + [15,7] + ] +*/ + +import java.util.ArrayList; +import java.util.List; + +class TreeNode { + int val; + TreeNode left; + TreeNode right; + TreeNode(int x) { + val = x; + } +} + +public class Solution { + List> listAll = new ArrayList<>(); + + public List> levelOrder(TreeNode root) { + levelOrder(root, 0); + return listAll; + } + + /** + * @param root node of tree + * @param depth depth of tree + */ + public void levelOrder(TreeNode root, int depth) { + if (root == null) + return; + List list = null; + if (depth == listAll.size()) { + list = new ArrayList<>(); + listAll.add(list); + } else { + list = listAll.get(depth); + } + list.add(root.val); + levelOrder(root.left, depth + 1); + levelOrder(root.right, depth + 1); + } +} diff --git a/xdu/passer/Java/passer_102.md b/xdu/passer/Java/passer_102.md deleted file mode 100644 index 00c0c32..0000000 --- a/xdu/passer/Java/passer_102.md +++ /dev/null @@ -1,56 +0,0 @@ -Problem: ---- -### Binary Tree Level Order Traversal -Given a binary tree, return the level order traversal of its nodes' values. -(ie: from left to right, level by level). - -For example: -Given binary tree -[3,9,20,null,null,15,7] -  3 -  /  \ - 9 20 -   /   \ -   15  7 -return its level order traversal as: -[ - [3], - [9,20], - [15,7] -] - -Code: ---- -``` -/** - * Definition for a binary tree node. - * public class TreeNode { - * int val; - * TreeNode left; - * TreeNode right; - * TreeNode(int x) { val = x; } - * } - */ -class Solution { - List> listAll = new ArrayList<>(); - public List> levelOrder(TreeNode root) { - levelOrder(root,0); - return listAll; - } - - public void levelOrder(TreeNode root,int depth){ - if(root == null) return; - List list = null; - if(depth == listAll.size()) { - list = new ArrayList<>(); - listAll.add(list); - } - else { - list = listAll.get(depth); - } - list.add(root.val); - levelOrder(root.left,depth + 1); - levelOrder(root.right,depth + 1); - } -} -``` From 16d32c9c467ee9f231f86d18d94d8866e9d57116 Mon Sep 17 00:00:00 2001 From: passer <1227118745@qq.com> Date: Thu, 21 Mar 2019 20:50:29 +0800 Subject: [PATCH 4/4] =?UTF-8?q?add=20sthe=20olution=20of=20leetcode=20prob?= =?UTF-8?q?lem=20s=20114=E3=80=81124=E3=80=81136?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- xdu/passer/Java/passer_114.java | 43 +++++++++++++++++++++++++++++++++ xdu/passer/Java/passer_124.java | 29 ++++++++++++++++++++++ xdu/passer/Java/passer_136.java | 26 ++++++++++++++++++++ 3 files changed, 98 insertions(+) create mode 100644 xdu/passer/Java/passer_114.java create mode 100644 xdu/passer/Java/passer_124.java create mode 100644 xdu/passer/Java/passer_136.java diff --git a/xdu/passer/Java/passer_114.java b/xdu/passer/Java/passer_114.java new file mode 100644 index 0000000..275fa12 --- /dev/null +++ b/xdu/passer/Java/passer_114.java @@ -0,0 +1,43 @@ +package com.passer._0321; + +/* +Given a binary tree, flatten it to a linked list in-place. +For example, given the following tree: + 1 + / \ + 2 5 + / \ \ +3 4 6 +The flattened tree should look like: +1 + \ + 2 + \ + 3 + \ + 4 + \ + 5 + \ + 6 +*/ +public class Flatten { + public void flatten(TreeNode root) { + helper(root); + } + + private TreeNode helper(TreeNode root) { + if (root == null) + return null; + TreeNode ans = helper(root.left); + root.left = helper(root.right); + root.right = ans; + ans = root; + while (ans.right != null) { + ans = ans.right; + } + ans.right = root.left; + root.left = null; + return root; + } +} \ No newline at end of file diff --git a/xdu/passer/Java/passer_124.java b/xdu/passer/Java/passer_124.java new file mode 100644 index 0000000..1aed7ab --- /dev/null +++ b/xdu/passer/Java/passer_124.java @@ -0,0 +1,29 @@ +package com.passer._0321; + +class TreeNode { + int val; + TreeNode left; + TreeNode right; + + TreeNode(int x) { + val = x; + } +} + +public class MaxSumOfPath { + int maxValue; + + public int maxPathSum(TreeNode root) { + maxValue = Integer.MIN_VALUE; + maxPathDown(root); + return maxValue; + } + + private int maxPathDown(TreeNode node) { + if (node == null) return 0; + int left = Math.max(0, maxPathDown(node.left)); + int right = Math.max(0, maxPathDown(node.right)); + maxValue = Math.max(maxValue, left + right + node.val); + return Math.max(left, right) + node.val; + } +} diff --git a/xdu/passer/Java/passer_136.java b/xdu/passer/Java/passer_136.java new file mode 100644 index 0000000..2025d65 --- /dev/null +++ b/xdu/passer/Java/passer_136.java @@ -0,0 +1,26 @@ +package com.passer._0321; + +/*Given a non-empty array of integers, every element appears twice except for one. Find that single one. + + Note: + + Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory? + + Example 1: + + Input: [2,2,1] + Output: 1 + Example 2: + + Input: [4,1,2,1,2] + Output: 4 +*/ +public class SingleNum { + public int singleNumber(int[] nums) { + int ret = 0; + for (int i = 0; i < nums.length; i++) { + ret ^= nums[i]; + } + return ret; + } +}