20181029

Author: fay111101

src/main/java/leetcode/array/_153_FindMinimumInRotatedSortedArry.java

@@ -0,0 +1,64 @@
+package leetcode.dpandgreedy;
+/**
+ * 在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。
+
+ 你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。
+
+ 如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。
+
+ 说明:
+
+ 如果题目有解，该答案即为唯一答案。
+ 输入数组均为非空数组，且长度相同。
+ 输入数组中的元素均为非负数。
+ 示例 1:
+
+ 输入:
+ gas  = [1,2,3,4,5]
+ cost = [3,4,5,1,2]
+
+ 输出: 3
+
+ 解释:
+ 从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
+ 开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油
+ 开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油
+ 开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油
+ 开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油
+ 开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。
+ 因此，3 可为起始索引。
+ 示例 2:
+
+ 输入:
+ gas  = [2,3,4]
+ cost = [3,4,3]
+
+ 输出: -1
+
+ 解释:
+ 你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。
+ 我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油
+ 开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油
+ 开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油
+ 你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
+ 因此，无论怎样，你都不可能绕环路行驶一周。
+
+ http://blog.csdn.net/kenden23/article/details/14106137
+*/
+public class _134_GasStation {
+
+    public int canCompleteCircuit(int[] gas,int[] cost){
+        int total=0;
+        int curSum=0;
+        int start=0;
+        for(int i=0;i<gas.length;i++){
+            total+=gas[i]-cost[i];
+            curSum+=gas[i]-cost[i];
+            if(curSum<0){
+                start=(i+1)%(gas.length);
+                curSum=0;
+            }
+        }
+        return total>=0?start:-1;
+    }
+}

src/main/java/leetcode/dpandgreedy/GasStation.java

@@ -0,0 +1,88 @@
+package leetcode.search;
+
+/**
+ * Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
+ *
+ * (i.e.,  [0,1,2,4,5,6,7] might become  [4,5,6,7,0,1,2]).
+ *
+ * Find the minimum element.
+ *
+ * You may assume no _51_duplicate exists in the array.
+ *
+ * Example 1:
+ *
+ * Input: [3,4,5,1,2]
+ * Output: 1
+ * Example 2:
+ *
+ * Input: [4,5,6,7,0,1,2]
+ * Output: 0
+ *
+ *
+ */
+
+
+public class _153_FindMinimumInRotatedSortedArry {
+
+
+    public int findMin(int[] nums) {
+        if(nums==null||nums.length==0) return -1;
+        int mid=0;
+        int left=0,right=nums.length-1;
+        //控制nums[left]>=nums[right].使第一个指针永远指向第一个递增子区间，第二个指针永远指向第二个递增子区间
+        while(nums[left]>=nums[right]&&left<right){
+            //第一个指针已经到达第一个子区间的末尾
+            if(right-left==1){
+                mid=right;
+                break;
+            }
+            mid=(left+right)>>1;
+            if(nums[mid]>nums[left]){
+                left=mid;
+            }else{
+                right=mid;
+            }
+        }
+
+        return nums[mid];
+    }
+
+    public int findMin1(int[] nums) {
+        int start = 0;
+        int end = nums.length - 1;
+        int mid = 0;
+        while (start < end) { //注意这里和普通的二分查找不同，这里是start < end不是 start <= end.
+            mid = start + (end - start)/2;
+            if (nums[mid] > nums[end])
+                start = mid + 1; //此时可以扔掉mid的值
+            else
+                end = mid;//此时不能扔掉mid的值
+        }
+        return nums[end]; //退出循环说明start与end相等，所以只剩一个元素可能，所以return [start]或者return [end]都可以了。
+        //注意不能return mid，可以从{2,1}这个输入看出来。
+
+    }
+
+    //二分查找
+    //https://www.cnblogs.com/luoxn28/p/5767571.html
+    public int binarySerach(int[] array, int key) {
+        int left = 0;
+        int right = array.length - 1;
+
+        // 这里必须是 <=
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (array[mid] == key) {
+                return mid;
+            }
+            else if (array[mid] < key) {
+                left = mid + 1;
+            }
+            else {
+                right = mid - 1;
+            }
+        }
+
+        return -1;
+    }
+}

src/main/java/leetcode/dpandgreedy/_134_GasStation.java

@@ -1,4 +1,4 @@
-package leetcode.array;
+package leetcode.search;
 
 /**
  假设按照升序排序的数组在预先未知的某个点上进行了旋转。
@@ -48,4 +48,21 @@ public int findMin(int[] nums) {
         return min;
     }
 
+    public int findMin1(int[] nums){
+        int n=nums.length;
+        int l=0,r=n-1,mid;
+        while(l<r){
+            mid=l+(r-l)/2;
+            if(nums[mid]>nums[r]){
+                l=mid+1;
+            }else if(nums[mid]<nums[r]){
+                r=mid;
+            }else{
+                r--;
+            }
+        }
+        //l==r的时候跳出循环，此时这个值为最小值
+        return nums[l];
+    }
+
 }

src/main/java/leetcode/search/_153_FindMinimumInRotatedSortedArry.java

@@ -1,9 +1,28 @@
 package leetcode.tree;
 
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.Queue;
+import java.util.*;
 
+/**
+ * 给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，
+ * 层与层之间交替进行）。
+
+ 例如：
+ 给定二叉树 [3,9,20,null,null,15,7],
+
+ 3
+ / \
+ 9  20
+ /  \
+ 15   7
+ 返回锯齿形层次遍历如下：
+
+ [
+ [3],
+ [20,9],
+ [15,7]
+ ]
+
+ */
 
 public class _103_BinaryTreeZigZagLevelOrderTraversal {
     public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
@@ -37,4 +56,38 @@ public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
         return result;
 
     }
+
+    public List<List<Integer>> zigzagLevelOrder1(TreeNode root) {
+        List<List<Integer>> res=new ArrayList<>();
+        if(root==null) return res;
+        List<Integer> result;
+        Stack<TreeNode> s1=new Stack<>(),s2=new Stack<>();
+        s1.push(root);
+        while(!s1.isEmpty()||!s2.isEmpty()){
+            if(!s1.isEmpty()){
+                ArrayList<Integer> list=new ArrayList<Integer>();
+                while(!s1.isEmpty()){
+                    TreeNode p=s1.pop();
+                    list.add(p.val);
+                    if(p.left!=null)
+                        s2.add(p.left);
+                    if(p.right!=null)
+                        s2.add(p.right);
+                }
+                res.add(list);
+            }else {
+                ArrayList<Integer> list=new ArrayList<Integer>();
+                while(!s2.isEmpty()){
+                    TreeNode p=s2.pop();
+                    if(p.right!=null)
+                        s1.add(p.right);
+                    if(p.left!=null)
+                        s1.add(p.left);
+                    list.add(p.val);
+                }
+                res.add(list);
+            }
+        }
+        return res;
+    }
 }