20181027

Author: fay111101

algorithm.iml

@@ -3,7 +3,7 @@
   <component name="NewModuleRootManager" inherit-compiler-output="true">
     <exclude-output />
     <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />

src/main/java/leetcode/array/_11_MaxArea.java

@@ -1,4 +1,39 @@
 package leetcode.array;
 
+/**
+ * 给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。
+ * 在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。
+ * 找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
+ * 说明：你不能倾斜容器，且 n 的值至少为 2。
+ */
 public class _11_MaxArea {
+    //暴力求解1
+    public int maxArea(int[] height) {
+        int max = Integer.MIN_VALUE;
+        for (int i = 0; i < height.length; i++) {
+            for (int j = i + 1; j < height.length; j++) {
+                int h = height[i] > height[j] ? height[j] : height[i];
+                if (h * (j - i) > max)
+                    max = h * (j - i);
+            }
+        }
+        return max;
+    }
+
+    //
+    public int maxArea1(int[] height) {
+        int max = Integer.MIN_VALUE;
+        for (int i = 0, j = height.length - 1; i < j; ) {
+            if (height[i] > height[j]) {
+                max = Math.max(max, height[j] * (j - i));
+                j--;
+
+            } else {
+                max = Math.max(max, height[i] * (j - i));
+                i++;
+            }
+        }
+        return max;
+    }
 }
+

src/main/java/leetcode/array/_121_BestTimeToBuyAndSellStock.java

@@ -1,12 +1,24 @@
 package leetcode.array;
 /*
-Say you have an array for which the i th element is the price of a given stock
-on day i.
-If you were only permitted to complete at most one transaction
-(ie, buy one and sell one share of the stock),
- design an algorithm to find the maximum profit.
+给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
+
+如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。
+
+注意你不能在买入股票前卖出股票。
+
+示例 1:
+
+输入: [7,1,5,3,6,4]
+输出: 5
+解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
+     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
+示例 2:
+
+输入: [7,6,4,3,1]
+输出: 0
+解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
 */
-public class BestTimeToBuyAndSellStock {
+public class _121_BestTimeToBuyAndSellStock {
 
     public int maxProfit(int[] prices){
         if(prices==null||prices.length==0){

src/main/java/leetcode/array/_122_BestTimeToBuyAndSellStock2.java

@@ -1,14 +1,34 @@
 package leetcode.array;
 /*
-Say you have an array for which the i th element is the price of a given stock
- on day i.
-Design an algorithm to find the maximum profit. You may complete as many
-transactions as you like (ie, buy one and sell one share of the stock multiple
- times). However, you may not engage in multiple transactions at the same time
- (ie, you must sell the stock before you buy again).
+给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
+
+设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
+
+注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
+
+示例 1:
+
+输入: [7,1,5,3,6,4]
+输出: 7
+解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
+     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
+示例 2:
+
+输入: [1,2,3,4,5]
+输出: 4
+解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
+     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
+     因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
+示例 3:
+
+输入: [7,6,4,3,1]
+输出: 0
+解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
+
 */
 
-public class BestTimeToBuyAndSellStock2 {
+public class _122_BestTimeToBuyAndSellStock2 {
+    //贪心
     public int maxProfit(int[] prices) {
         if(prices==null||prices.length==0){
             return 0;

src/main/java/leetcode/array/_154_FindMinmumInRotateSortedArray2.java

@@ -1,28 +1,25 @@
 package leetcode.array;
 
 /**
- * Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
- * <p>
- * (i.e.,  [0,1,2,4,5,6,7] might become  [4,5,6,7,0,1,2]).
- * <p>
- * Find the minimum element.
- * <p>
- * The array may contain duplicates.
- * <p>
- * Example 1:
- * <p>
- * Input: [1,3,5]
- * Output: 1
- * Example 2:
- * <p>
- * Input: [2,2,2,0,1]
- * Output: 0
- * Note:
- * <p>
- * This is a follow up problem to Find Minimum in Rotated Sorted Array.
- * Would allow duplicates affect the run-time complexity? How and why?
+ 假设按照升序排序的数组在预先未知的某个点上进行了旋转。
+
+ ( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
+
+ 请找出其中最小的元素。
+
+ 注意数组中可能存在重复的元素。
+
+ 示例 1：
+
+ 输入: [1,3,5]
+ 输出: 1
+ 示例 2：
+
+ 输入: [2,2,2,0,1]
+ 输出: 0
  */
 public class _154_FindMinmumInRotateSortedArray2 {
+
     public int findMin(int[] nums) {
         if (nums == null || nums.length == 0) return -1;
         int mid = 0;

src/main/java/leetcode/array/_15_Sum3.java

@@ -2,73 +2,75 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 
-/* Given an array S of n integers, are there elements a, b, c in S such that a +
- b + c = 0? Find all unique triplets in the array which gives the sum of zero.
+/**
+ * 给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，
+ * 使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。
+ * <p>
+ * 注意：答案中不可以包含重复的三元组。
+ * <p>
+ * 例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，
+ * <p>
+ * 满足要求的三元组集合为：
+ * [
+ * [-1, 0, 1],
+ * [-1, -1, 2]
+ * ]
+ */
+public class _15_Sum3 {
 
-Note:
-
-    Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ≤ b ≤ c)
-    The solution set must not contain _51_duplicate triplets.
-
-
-    For example, given array S = {-1 0 1 2 -1 -4},
-
-    A solution set is:
-    (-1, 0, 1)
-    (-1, -1, 2)
-*/
-public class Sum3 {
-    public ArrayList<ArrayList<Integer>> threeSum(int[] num) {
-        ArrayList<ArrayList<Integer>> result=new ArrayList<>();
-        Arrays.sort(num);
-        for(int k=0;k<num.length;k++){
-            int target=0-num[k];
-            int i=k+1,j=num.length-1;
-            if (k != 0 && num[k] == num[k - 1]) {
+    public List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> result = new ArrayList<>();
+        Arrays.sort(nums);
+        for (int k = 0; k < nums.length; k++) {
+            int target = 0 - nums[k];
+            int i = k + 1, j = nums.length - 1;
+            if (k != 0 && nums[k] == nums[k - 1]) {
                 continue;
             }
-            while(i<j){
-                if((num[i]+num[j])==target){
-                    ArrayList<Integer> res=new ArrayList<>();
-                    res.add(num[k]);
-                    res.add(num[i]);
-                    res.add(num[j]);
+            while (i < j) {
+                if ((nums[i] + nums[j]) == target) {
+                    ArrayList<Integer> res = new ArrayList<>();
+                    res.add(nums[k]);
+                    res.add(nums[i]);
+                    res.add(nums[j]);
                     result.add(res);
-                    while(i<j&&num[i]==num[i+1]){
+                    while (i < j && nums[i] == nums[i + 1]) {
                         i++;
                     }
-                    while(i<j&&num[j]==num[j-1]){
+                    while (i < j && nums[j] == nums[j - 1]) {
                         j--;
                     }
                     i++;
                     j--;
-                }else if((num[i]+num[j])<target){
+                } else if ((nums[i] + nums[j]) < target) {
                     i++;
-                }else{
+                } else {
                     j--;
                 }
 
             }
 
         }
-        return  result;
+        return result;
     }
-    public static void main(String[] args){
-        Sum3 test=new Sum3();
-        int[] num={-1, 0 ,1 ,2 ,-1 ,-4};
-        int[] num1={0,0,0,0};
-        int[] num2={-2,0,1,1,2};
-        ArrayList<ArrayList<Integer>> result=test.threeSum(num);
+
+    public static void main(String[] args) {
+        _15_Sum3 test = new _15_Sum3();
+        int[] num = {-1, 0, 1, 2, -1, -4};
+        int[] num1 = {0, 0, 0, 0};
+        int[] num2 = {-2, 0, 1, 1, 2};
+        List<List<Integer>> result = test.threeSum(num);
         /*for(ArrayList<Integer> res:result){
             for(int a:res){
                 System.out.print(a);
             }
             System.out.println();
         }*/
-        ArrayList<ArrayList<Integer>> result1=test.threeSum(num2);
-        for(ArrayList<Integer> res:result1){
-            for(int a:res){
+        List<List<Integer>> result1 = test.threeSum(num2);
+        for (List<Integer> res : result1) {
+            for (int a : res) {
                 System.out.print(a);
             }
             System.out.println();

src/main/java/leetcode/array/_16_SumClosest.java

@@ -2,31 +2,34 @@
 
 import java.util.Arrays;
 
-/* Given an array S of n integers, find three integers in S such that the sum is
-closest to a given number, target. Return the sum of the three integers. You may
-assume that each input would have exactly one solution.
+/**
+ * 给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。
+ * 返回这三个数的和。假定每组输入只存在唯一答案。
 
-    For example, given array S = {-1 2 1 -4}, and target = 1.
+ 例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.
 
-    The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
-*/
-public class SumClosest {
-    public int threeSumClosest(int[] num, int target) {
-        int closet=num[0]+num[1]+num[2];
+ 与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).
+ */
+public class _16_SumClosest {
+
+    public int threeSumClosest(int[] nums, int target) {
+        int closet=nums[0]+nums[1]+nums[2];
         int diff=Math.abs(closet-target);
         int sum=0;
-        Arrays.sort(num);
-        for(int i=0;i<num.length-2;i++){
+        Arrays.sort(nums);
+        for(int i=0;i<nums.length-2;i++){
             int left=i+1;
-            int right=num.length-1;
+            int right=nums.length-1;
             while(left<right){
-                sum=num[i]+num[left]+num[right];
+                sum=nums[i]+nums[left]+nums[right];
                 int newDiff=Math.abs(sum-target);
                 if(newDiff<diff){
                     diff=newDiff;
                     closet=sum;
                 }
-                if(sum<closet){
+                if(sum==closet){
+                    return closet;
+                }else if(sum<closet){
                     left++;
                 }else{
                     right--;