From 8d35302c440451c1c31a367ad87f059c5d7a5c22 Mon Sep 17 00:00:00 2001 From: liguangliang Date: Sat, 23 Jan 2016 03:05:21 -0800 Subject: [PATCH 1/2] no message --- GuangliangLi/HW1/MergeTwoSortedLists21.java | 35 +++++++++++++ GuangliangLi/HW1/RemoveDuplicates82.java | 27 ++++++++++ GuangliangLi/HW1/ReverseLinkedList92.java | 36 +++++++++++++ GuangliangLi/HW2/BinaryTreePaths.java | 47 +++++++++++++++++ .../HW2/ConstructBinaryTreeFromInPost.java | 48 +++++++++++++++++ .../HW2/ConstructBinaryTreeFromInPre.java | 51 +++++++++++++++++++ GuangliangLi/HW2/ConvertSortedArrayToBST.java | 33 ++++++++++++ GuangliangLi/HW2/LowestCommonAncestor.java | 21 ++++++++ GuangliangLi/HW2/LowestCommonAncestorBST.java | 19 +++++++ .../HW2/MaximumDepthofBinaryTree.java | 29 +++++++++++ GuangliangLi/HW2/SymmetricTree.java | 24 +++++++++ .../HW2/ValidateBinarySearchTree.java | 34 +++++++++++++ GuangliangLi/HW3/CombinationSum.java | 40 +++++++++++++++ GuangliangLi/hw1 | 0 14 files changed, 444 insertions(+) create mode 100644 GuangliangLi/HW1/MergeTwoSortedLists21.java create mode 100644 GuangliangLi/HW1/RemoveDuplicates82.java create mode 100644 GuangliangLi/HW1/ReverseLinkedList92.java create mode 100644 GuangliangLi/HW2/BinaryTreePaths.java create mode 100644 GuangliangLi/HW2/ConstructBinaryTreeFromInPost.java create mode 100644 GuangliangLi/HW2/ConstructBinaryTreeFromInPre.java create mode 100644 GuangliangLi/HW2/ConvertSortedArrayToBST.java create mode 100644 GuangliangLi/HW2/LowestCommonAncestor.java create mode 100644 GuangliangLi/HW2/LowestCommonAncestorBST.java create mode 100644 GuangliangLi/HW2/MaximumDepthofBinaryTree.java create mode 100644 GuangliangLi/HW2/SymmetricTree.java create mode 100644 GuangliangLi/HW2/ValidateBinarySearchTree.java create mode 100644 GuangliangLi/HW3/CombinationSum.java delete mode 100644 GuangliangLi/hw1 diff --git a/GuangliangLi/HW1/MergeTwoSortedLists21.java b/GuangliangLi/HW1/MergeTwoSortedLists21.java new file mode 100644 index 0000000..fe09fa5 --- /dev/null +++ b/GuangliangLi/HW1/MergeTwoSortedLists21.java @@ -0,0 +1,35 @@ +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode(int x) { val = x; } + * } + */ +public class MergeTwoSortedLists21 { + public ListNode mergeTwoLists(ListNode l1, ListNode l2) { + ListNode dummyHead = new ListNode(0); + ListNode p = new ListNode(0); + dummyHead.next = p; + + while(l1 != null && l2 !=null){ + if(l1.val < l2.val){ + p.next = l1; + l1 = l1.next; + }else{ + p.next = l2; + l2 = l2.next; + } + p = p.next; + } + + if(l1 != null){ + p.next = l1; + } + if(l2 != null){ + p.next = l2; + } + return dummyHead.next.next; + + } +} \ No newline at end of file diff --git a/GuangliangLi/HW1/RemoveDuplicates82.java b/GuangliangLi/HW1/RemoveDuplicates82.java new file mode 100644 index 0000000..b9caf46 --- /dev/null +++ b/GuangliangLi/HW1/RemoveDuplicates82.java @@ -0,0 +1,27 @@ +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode(int x) { val = x; } + * } + */ +public class RemoveDuplicates82 { + public ListNode deleteDuplicates(ListNode head) { + if (head == null) return head; + ListNode dummyHead = new ListNode(0); + dummyHead.next = head; + ListNode p = dummyHead; + while(p.next != null && p.next.next != null){ + if (p.next.val == p.next.next.val){ + int dup = p.next.val; + while (p.next != null && p.next.val == dup){ + p.next = p.next.next; + } + }else{ + p = p.next; + } + } + return dummyHead.next; + } +} \ No newline at end of file diff --git a/GuangliangLi/HW1/ReverseLinkedList92.java b/GuangliangLi/HW1/ReverseLinkedList92.java new file mode 100644 index 0000000..0d42624 --- /dev/null +++ b/GuangliangLi/HW1/ReverseLinkedList92.java @@ -0,0 +1,36 @@ +package tpmp; + +public class ReverseLinkedList92 { + public ListNode reverseBetween(ListNode head, int m, int n) { + ListNode dummyHead = new ListNode(0); + dummyHead.next = head; + ListNode p = new ListNode(0); + p = head; + int length = 0; + while(p != null){ + length++; + p = p.next; + } + if (length <= 1) return head; + ListNode preNode = new ListNode(0); + preNode = dummyHead; + ListNode curNode = new ListNode(0); + ListNode nextNode = new ListNode(0); + ListNode mNode = new ListNode(0); + for(int i = 1; i <= n; i++){ + if(i < m){ + preNode = preNode.next; + }else if(i == m){ + mNode = preNode.next; + curNode = mNode.next; + }else if(i>m){ + nextNode = curNode.next; + curNode.next = preNode.next; + preNode.next = curNode; + mNode.next = nextNode; + curNode = nextNode; + } + } + return dummyHead.next; + } +} diff --git a/GuangliangLi/HW2/BinaryTreePaths.java b/GuangliangLi/HW2/BinaryTreePaths.java new file mode 100644 index 0000000..c8fea2c --- /dev/null +++ b/GuangliangLi/HW2/BinaryTreePaths.java @@ -0,0 +1,47 @@ +package tpmp; + +import java.util.ArrayList; +import java.util.List; +import java.util.Stack; + +public class BinaryTreePaths { + + public List getBinaryTreePaths(TreeNode root) { + if (root == null) return null; + List path = new ArrayList(); + List res = new ArrayList(); + getPath(root, path, res); + Stack stack = new Stack(); + stack.clone(); + return res; + + } + + public void getPath(TreeNode root, List path, List res){ + if(path.size() == 0){ + path.add(String.valueOf(root.val)); + }else{ + path.add("->".concat(String.valueOf(root.val))); + } + if(root.left == null && root.right == null){ + connectNode(path, res); + path.remove(path.size()-1); + }else{ + if(root.left != null){ + getPath(root.left, path, res); + } + if(root.right != null){ + getPath(root.right, path, res); + } + path.remove(path.size()-1); + } + } + public void connectNode(List path, List res){ + StringBuffer tmp = new StringBuffer(); + for(int i =0; i < path.size(); i++){ + tmp.append(path.get(i)); + } + res.add(tmp.toString()); + } + +} diff --git a/GuangliangLi/HW2/ConstructBinaryTreeFromInPost.java b/GuangliangLi/HW2/ConstructBinaryTreeFromInPost.java new file mode 100644 index 0000000..6e074c3 --- /dev/null +++ b/GuangliangLi/HW2/ConstructBinaryTreeFromInPost.java @@ -0,0 +1,48 @@ +package tpmp; + +public class ConstructBinaryTreeFromInPost { + + public TreeNode buildTree(int[] inorder, int[] postorder){ + if(inorder == null || postorder == null || inorder.length == 0 || postorder.length == 0) { + return null; + } + TreeNode root = new TreeNode(postorder[postorder.length-1]); + int position = getPosition(postorder[postorder.length-1], inorder); + int[] leftInOrder = getSubOrder(inorder, position, true, true); + int[] rightInOrder = getSubOrder(inorder, position, false, true); + int[] leftPostOrder = getSubOrder(postorder, position, true, false); + int[] rightPostOrder = getSubOrder(postorder, position, false, false); + root.left = buildTree(leftInOrder, leftPostOrder); + root.right = buildTree(rightInOrder, rightPostOrder); + return root; + } + + private int getPosition(int target, int[] targetArr){ + for(int i = 0; i < targetArr.length; i++){ + if(target == targetArr[i]){ + return i; + } + } + return 0; + } + + private int[] getSubOrder(int[] orderArr, int position, boolean LeftFlag, boolean InFlag){ + int[] retArr; + if(LeftFlag){ + retArr = new int[position]; + System.arraycopy(orderArr, 0, retArr, 0, position); + }else{ + if(InFlag){ + retArr = new int[orderArr.length - position - 1]; + System.arraycopy(orderArr, position + 1, retArr, 0, orderArr.length - position - 1); + }else{ + retArr = new int[orderArr.length - position - 1]; + System.arraycopy(orderArr, position, retArr, 0, orderArr.length - position - 1); + } + } + return retArr; + } + + + +} diff --git a/GuangliangLi/HW2/ConstructBinaryTreeFromInPre.java b/GuangliangLi/HW2/ConstructBinaryTreeFromInPre.java new file mode 100644 index 0000000..52170ae --- /dev/null +++ b/GuangliangLi/HW2/ConstructBinaryTreeFromInPre.java @@ -0,0 +1,51 @@ +package tpmp; + +public class ConstructBinaryTreeFromInPre { + + public TreeNode buildTree(int[] preorder, int[] inorder) { + if (preorder == null) + return null; + if (preorder.length == 0) + return null; + TreeNode root = new TreeNode(preorder[0]); + int position = getPosition(preorder[0], inorder); + int[] leftSubInOrder = getSubOrder(inorder, position, true, true); + int[] rightSubInOrder = getSubOrder(inorder, position, false, true); + int[] leftSubPreOrder = getSubOrder(preorder, position, true, false); + int[] rightSubPreOrder = getSubOrder(preorder, position, false, false); + + root.left = buildTree(leftSubPreOrder, leftSubInOrder); + root.right = buildTree(rightSubPreOrder, rightSubInOrder); + return root; + + } + + private int getPosition(int target, int[] targetOrder) { + int i; + for (i = 0; i < targetOrder.length; i++) { + if (targetOrder[i] == target) { + return i; + } + } + return 0; + } + + private int[] getSubOrder(int[] targetOrder, int pos, boolean leftFlag, boolean inFlag) { + int[] subOrder; + if (leftFlag) { + if (inFlag) { + subOrder = new int[pos]; + System.arraycopy(targetOrder, 0, subOrder, 0, pos); + } else { + subOrder = new int[pos]; + System.arraycopy(targetOrder, 1, subOrder, 0, pos); + } + } else { + subOrder = new int[targetOrder.length - pos - 1]; + System.arraycopy(targetOrder, pos + 1, subOrder, 0, targetOrder.length - pos - 1); + } + return subOrder; + + } + +} diff --git a/GuangliangLi/HW2/ConvertSortedArrayToBST.java b/GuangliangLi/HW2/ConvertSortedArrayToBST.java new file mode 100644 index 0000000..013a550 --- /dev/null +++ b/GuangliangLi/HW2/ConvertSortedArrayToBST.java @@ -0,0 +1,33 @@ +package tpmp; + +public class ConvertSortedArrayToBST { + public TreeNode sortedArrayToBST(int[] nums) { + if(nums == null || nums.length == 0) return null; + + TreeNode root = new TreeNode(nums[nums.length/2]); + if(nums.length == 1) return root; + int[] leftSubNums = getSubNums(nums, true); + int[] rightSubNums = getSubNums(nums, false); + root.left = sortedArrayToBST(leftSubNums); + root.right = sortedArrayToBST(rightSubNums); + return root; + } + + private int[] getSubNums(int[] nums, boolean leftFlag){ + int[] ret = new int[nums.length/2];; + if(leftFlag){ + System.arraycopy(nums, 0, ret, 0, nums.length/2); + }else{ + if(nums.length%2 == 0){ + ret = new int[nums.length/2 -1]; + System.arraycopy(nums, nums.length/2 + 1, ret, 0, nums.length/2 -1); + }else{ + System.arraycopy(nums, nums.length/2 + 1, ret, 0, nums.length/2); + } + + } + return ret; + } + + +} diff --git a/GuangliangLi/HW2/LowestCommonAncestor.java b/GuangliangLi/HW2/LowestCommonAncestor.java new file mode 100644 index 0000000..1c96b78 --- /dev/null +++ b/GuangliangLi/HW2/LowestCommonAncestor.java @@ -0,0 +1,21 @@ +package tpmp; + +public class LowestCommonAncestor { + public TreeNode findLowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { + if (root == null){ + return null; + } + if(root.val == p.val || root.val == q.val){ + return root; + } + TreeNode leftLCA = findLowestCommonAncestor(root.left, p, q); + TreeNode rightLCA = findLowestCommonAncestor(root.right, p, q); + if(leftLCA != null && rightLCA != null){ + return root; + }else if(leftLCA != null){ + return leftLCA; + }else{ + return rightLCA; + } + } +} diff --git a/GuangliangLi/HW2/LowestCommonAncestorBST.java b/GuangliangLi/HW2/LowestCommonAncestorBST.java new file mode 100644 index 0000000..bc461aa --- /dev/null +++ b/GuangliangLi/HW2/LowestCommonAncestorBST.java @@ -0,0 +1,19 @@ +package tpmp; + +public class LowestCommonAncestorBST { + public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { + if(p.val > q.val){ + TreeNode r = new TreeNode(0); + r = p; + p = q; + q = r; + } + if(root.val >= p.val && root.val <= q.val){ + return root; + }else if(root.val < p.val){ + return lowestCommonAncestor(root.right, p, q); + }else{ + return lowestCommonAncestor(root.left, p, q); + } + } +} diff --git a/GuangliangLi/HW2/MaximumDepthofBinaryTree.java b/GuangliangLi/HW2/MaximumDepthofBinaryTree.java new file mode 100644 index 0000000..d46ce21 --- /dev/null +++ b/GuangliangLi/HW2/MaximumDepthofBinaryTree.java @@ -0,0 +1,29 @@ +package tpmp; + +import java.util.ArrayList; + +public class MaximumDepthofBinaryTree { + public int maxDepth(TreeNode root) { + ArrayList lengthList = new ArrayList(); + int[] length = new int[1]; + length[0] = 0; + getLength(root, lengthList, length); + int ret = 0; + for(int i=0; i lengthList, int[] length){ + if(root == null) return; + length[0] = length[0] + 1; + if(root.left == null && root.right == null){ + lengthList.add(length[0]); + }else{ + getLength(root.left, lengthList, length); + getLength(root.right, lengthList, length); + } + length[0] = length[0] - 1; + } +} diff --git a/GuangliangLi/HW2/SymmetricTree.java b/GuangliangLi/HW2/SymmetricTree.java new file mode 100644 index 0000000..b6d241e --- /dev/null +++ b/GuangliangLi/HW2/SymmetricTree.java @@ -0,0 +1,24 @@ +package tpmp; + +public class SymmetricTree { + public boolean isSymmetric(TreeNode root) { + if(root == null) return true; + if(root.left == null && root.right == null){ + return true; + } + return isSymmetricTree(root.left, root.right); + } + + private boolean isSymmetricTree(TreeNode left, TreeNode right){ + if(left == null && right == null) return true; + if(left == null && right !=null || right == null && left != null) return false; + + if(left.val == right.val){ + return isSymmetricTree(left.left, right.right) && isSymmetricTree(left.right, right.left); + }else{ + return false; + } + } + + +} diff --git a/GuangliangLi/HW2/ValidateBinarySearchTree.java b/GuangliangLi/HW2/ValidateBinarySearchTree.java new file mode 100644 index 0000000..7cab14e --- /dev/null +++ b/GuangliangLi/HW2/ValidateBinarySearchTree.java @@ -0,0 +1,34 @@ +package tpmp; + +import java.util.ArrayList; + +public class ValidateBinarySearchTree { + public boolean isValidBST(TreeNode root) { + if(root == null || root.left == null && root.right == null) return true; + ArrayList inTraversalList = new ArrayList(); + inTraversal(inTraversalList, root); + + for(int i = 1; i < inTraversalList.size(); i++){ + if (inTraversalList.get(i) <= inTraversalList.get(i-1)){ + return false; + } + } + return true; + } + + private void inTraversal(ArrayList inTraversalList, TreeNode root){ + if(root.left == null && root.right == null) { + inTraversalList.add(root.val); + return; + } + if(root.left != null){ + inTraversal(inTraversalList, root.left); + } + inTraversalList.add(root.val); + if(root.right != null){ + inTraversal(inTraversalList, root.right); + } + } + + +} diff --git a/GuangliangLi/HW3/CombinationSum.java b/GuangliangLi/HW3/CombinationSum.java new file mode 100644 index 0000000..f5aad95 --- /dev/null +++ b/GuangliangLi/HW3/CombinationSum.java @@ -0,0 +1,40 @@ +package tpmp; + +import java.util.ArrayList; + +public class CombinationSum { + public ArrayList> combinationSum1(int[] candidates, int target) { + + ArrayList path = new ArrayList(); + ArrayList> res = new ArrayList>(); + + dfs(path, res, 0, candidates, target); + return res; + + } + + public void dfs(ArrayList path, ArrayList> ret, int position, + int[] candidates, int target){ + int sum = getSum(path); + if(sum > target){ + return; + }else if(sum == target){ + ret.add(new ArrayList(path)); + return; + } + for(int i = position; i < candidates.length; i++){ + path.add(candidates[i]); + dfs(path, ret, i, candidates, target); + path.remove(path.size() - 1); + } + + } + + public int getSum(ArrayList path){ + int sum = 0; + for(int i = 0; i < path.size(); i++){ + sum = sum + path.get(i); + } + return sum; + } +} \ No newline at end of file diff --git a/GuangliangLi/hw1 b/GuangliangLi/hw1 deleted file mode 100644 index e69de29..0000000 From 170951e2430141a0bd1344e6b4d195d58a737d5e Mon Sep 17 00:00:00 2001 From: liguangliang Date: Mon, 25 Jan 2016 01:04:04 -0800 Subject: [PATCH 2/2] 01/25 --- GuangliangLi/HW3/CombinationSum.java | 9 +++- GuangliangLi/HW3/CombinationSum2.java | 64 +++++++++++++++++++++++++++ GuangliangLi/HW3/CombinationSum3.java | 48 ++++++++++++++++++++ GuangliangLi/HW3/Subsets.java | 25 +++++++++++ 4 files changed, 144 insertions(+), 2 deletions(-) create mode 100644 GuangliangLi/HW3/CombinationSum2.java create mode 100644 GuangliangLi/HW3/CombinationSum3.java create mode 100644 GuangliangLi/HW3/Subsets.java diff --git a/GuangliangLi/HW3/CombinationSum.java b/GuangliangLi/HW3/CombinationSum.java index f5aad95..e169820 100644 --- a/GuangliangLi/HW3/CombinationSum.java +++ b/GuangliangLi/HW3/CombinationSum.java @@ -1,15 +1,20 @@ package tpmp; import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; public class CombinationSum { - public ArrayList> combinationSum1(int[] candidates, int target) { + public List> combinationSum(int[] candidates, int target) { ArrayList path = new ArrayList(); ArrayList> res = new ArrayList>(); + Arrays.sort(candidates); dfs(path, res, 0, candidates, target); - return res; + + List> ret = new ArrayList<>(res); + return ret; } diff --git a/GuangliangLi/HW3/CombinationSum2.java b/GuangliangLi/HW3/CombinationSum2.java new file mode 100644 index 0000000..501166b --- /dev/null +++ b/GuangliangLi/HW3/CombinationSum2.java @@ -0,0 +1,64 @@ +package tpmp; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; + +public class CombinationSum2 { + public List> combinationSum2(int[] candidates, int target) { + + ArrayList path = new ArrayList(); + ArrayList> res = new ArrayList>(); + HashMap dupCheckMap = new HashMap(); + Arrays.sort(candidates); + + dfs(path, res, 0, candidates, target, dupCheckMap); + List> ret = new ArrayList<>(res); + return ret; + + } + + public void dfs(ArrayList path, ArrayList> ret, int position, + int[] candidates, int target, HashMap dupCheckMap){ + int sum = getSum(path); + if(sum > target){ + return; + }else if(sum == target){ + boolean existFlg = checkExist(path, dupCheckMap); + if (!existFlg){ + ret.add(new ArrayList(path)); + return; + } + } + for(int i = position; i < candidates.length; i++){ + path.add(candidates[i]); + dfs(path, ret, i+1, candidates, target, dupCheckMap); + path.remove(path.size() - 1); + } + + } + + public int getSum(ArrayList path){ + int sum = 0; + for(int i = 0; i < path.size(); i++){ + sum = sum + path.get(i); + } + return sum; + } + + public boolean checkExist(ArrayList path, HashMap dupCheckMap){ + + StringBuffer tmp = new StringBuffer(); + for(int num : path){ + tmp = tmp.append(String.valueOf(num)); + } + String key = tmp.toString(); + if(dupCheckMap.get(key) == null){ + dupCheckMap.put(key,key); + return false; + }else{ + return true; + } + } +} diff --git a/GuangliangLi/HW3/CombinationSum3.java b/GuangliangLi/HW3/CombinationSum3.java new file mode 100644 index 0000000..49742f9 --- /dev/null +++ b/GuangliangLi/HW3/CombinationSum3.java @@ -0,0 +1,48 @@ +package tpmp; + +import java.util.ArrayList; +import java.util.List; + +public class CombinationSum3 { + public List> combinationSum3(int k, int n) { + + ArrayList path = new ArrayList(); + ArrayList> res = new ArrayList>(); + int [] candidates = {1,2,3,4,5,6,7,8,9}; + + dfs(path, res, 0, candidates, k, n); + List> ret = new ArrayList<>(res); + return ret; + + } + + public void dfs(ArrayList path, ArrayList> ret, int position, + int[] candidates, int cnt, int target){ + int sum = getSum(path); + if(sum > target){ + return; + }else if(sum == target){ + if(path.size() == cnt){ + ret.add(new ArrayList(path)); + return; + } + } + for(int i = position; i < candidates.length; i++){ + path.add(candidates[i]); + dfs(path, ret, i + 1, candidates, cnt, target); + path.remove(path.size() - 1); + } + + } + + public int getSum(ArrayList path){ + int sum = 0; + for(int i = 0; i < path.size(); i++){ + sum = sum + path.get(i); + } + return sum; + } + + + +} diff --git a/GuangliangLi/HW3/Subsets.java b/GuangliangLi/HW3/Subsets.java new file mode 100644 index 0000000..aa5e38d --- /dev/null +++ b/GuangliangLi/HW3/Subsets.java @@ -0,0 +1,25 @@ +package tpmp; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class Subsets { + public List> subsets(int[] nums) { + Arrays.sort(nums); + ArrayList> ret = new ArrayList<>(); + ArrayList path = new ArrayList<>(); + getSubsets(ret, path, 0, nums); + List> res = new ArrayList<>(ret); + return res; + } + + private void getSubsets(ArrayList> ret, ArrayList path, int pos, int[] nums){ + ret.add(new ArrayList(path)); + for(int i = pos; i < nums.length; i++){ + path.add(nums[i]); + getSubsets(ret, path, i + 1, nums); + path.remove(path.size()-1); + } + } +}