Array and String

Author: Bahncard

lcJava/1.two-sum.java renamed to lcJava/Array and String Topics/1.two-sum.java

@@ -23,9 +23,8 @@ public int[] twoSum(int[] nums, int target) {
         return null;
     }
 }
-/**
- * 1. The order of indices in the return array should match the problem statement,
- * (i.e., the first index should be the one stored in the hashmap and the second should be the current index)
- */
+//注意：不要忘掉另一个return，每个条件对应肯定都有return
+//HashMap别写错：用wrapper class， 而且形式是开头大写
+
 // @lc code=end
 

lcJava/121.best-time-to-buy-and-sell-stock.java renamed to lcJava/Array and String Topics/121.best-time-to-buy-and-sell-stock.java

@@ -0,0 +1,36 @@
+/*
+ * @lc app=leetcode id=167 lang=java
+ *
+ * [167] Two Sum II - Input Array Is Sorted
+ */
+
+// @lc code=start
+class Solution {
+    public int[] twoSum(int[] numbers, int target) {
+        //sorted array->binary search
+        //for each element in the array, calculate the complement, binary search for the complement in the folowing subaaray
+        for(int i=0; i< numbers.length; i++){
+            //initilize the pointers:binary search from the next element in the array
+            int low= i+1; 
+            int high= numbers.length-1;
+            //start search
+            while(low <= high){
+                int mid= low + (high-low)/2;
+                //search for delta
+                if( numbers[mid] == target-numbers[i] ){
+                    return new int[]{i+1, mid+1};
+                }else if(numbers[mid] > target-numbers[i]){
+                    high = mid-1;
+                }else{
+                    low=mid+1;
+                }
+            }
+    }
+    return new int[]{-1,-1};
+        }
+}
+//一般对于sorted array，常见解法有binary search，two pointers 
+//这里用binary search
+
+// @lc code=end
+

lcJava/Array and String Topics/167.two-sum-ii-input-array-is-sorted-0.java

@@ -0,0 +1,30 @@
+/*
+ * @lc app=leetcode id=167 lang=java
+ *
+ * [167] Two Sum II - Input Array Is Sorted
+ */
+
+// @lc code=start
+class Solution {
+    public int[] twoSum(int[] numbers, int target) {
+        //sorted array-> two ppointers  
+        int l=0, r= numbers.length-1;
+      //  int sum = numbers[l]+ numbers[r]; if so the sum will be only calculated once 
+        while(l<r){
+            int sum = numbers[l]+ numbers[r];
+            if (sum == target){
+                return new int[]{l+1,r+1};
+            }else if(sum < target){
+                l++;
+            }else{
+                r--;
+            } 
+    }
+    return new int[]{-1,-1};
+    }
+}
+//一般对于sorted array，常见解法有binary search，two pointers 
+//这里用two pointers：one pointer at the beginning, the other at the end, calculate the sum at each interation
+// if the sum is too large, move the right pointer to the left; if the sum is too small, move the left pointer to the right
+// @lc code=end
+

lcJava/Array and String Topics/167.two-sum-ii-input-array-is-sorted.java

@@ -0,0 +1,32 @@
+/*
+ * @lc app=leetcode id=27 lang=java
+ *
+ * [27] Remove Element
+ */
+
+// @lc code=start
+class Solution {
+    public int removeElement(int[] nums, int val) {
+        //move the val to the end of the array
+        int newLength=nums.length;
+        for (int i = 0; i < newLength; i++) {
+            if(nums[i] == val){
+                nums[i]= nums[newLength-1]; 
+                newLength--;//contract the arr_length
+                i--; //go one element back to check if the swapped the elements again fits the requirement.
+                    // so in the next iteration i++, it goes exactly back to the i in the last iteration
+
+            }
+        }
+        return newLength;
+    }
+}
+ 
+ 
+/*
+Swap over:swapping the element to be removed with the last element in the array and then reducing the array size
+不需要将当前位置的值放到size-1位置，因为实际上是在缩短数组的有效长度，直接用末端的值覆盖要删除的位置，然后缩短数组的长度即可。
+这种方法的重点是避免多余的移动操作，而不是维护原始顺序。
+ */
+// @lc code=end
+

lcJava/209.minimum-size-subarray-sum.java renamed to lcJava/Array and String Topics/209.minimum-size-subarray-sum.java

@@ -0,0 +1,25 @@
+/*
+ * @lc app=leetcode id=27 lang=java
+ *
+ * [27] Remove Element
+ */
+
+// @lc code=start
+class Solution {
+    public int removeElement(int[] nums, int val) {
+        int s=0;
+        //for each is better : for (int num: nums)
+        for (int f=0; f<nums.length; f++){
+            if(nums[f]!= val){
+                nums[s]= nums[f];
+                s++;
+            }
+        }
+        return s; //s 增加几个就有几个元素
+    }
+}
+//slow-fast pointers, namley copy-over
+//The 2nd approach:
+//Swap over:swapping the element to be removed with the last element in the array and then reducing the array size
+// @lc code=end
+

lcJava/Array and String Topics/27.remove-element-0.java

@@ -0,0 +1,33 @@
+/*
+ * @lc app=leetcode id=35 lang=java
+ *
+ * [35] Search Insert Position
+ */
+
+// @lc code=start
+
+class Solution {
+    public int searchInsert(int[] nums, int target) {
+        int l=0, r=nums.length-1;
+        while(l<=r){
+            int mid = l+ (r-l)/2;
+            if(nums[mid]== target){
+                return mid;
+            }
+            else if(nums[mid]<target){
+                l=mid+1;
+            }
+            else
+            {
+                r=mid-1;
+            }
+            
+        }
+        return l;
+    }
+}
+//equivalent to : search the first value in the array that equals to or bigger than the target 
+//binary search with O（logn)
+// the loop condition : <=   (not looking for a pair so it makes senese in the '=' case)
+// @lc code=end
+

lcJava/Array and String Topics/27.remove-element.java

@@ -0,0 +1,37 @@
+/*
+ * @lc app=leetcode id=485 lang=java
+ *
+ * [485] Max Consecutive Ones
+ */
+
+// @lc code=start
+class Solution {
+    public int findMaxConsecutiveOnes(int[] nums) {
+        int maxCount = 0;
+        int left = 0, right = 0;
+        int n = nums.length;
+        // 双指针： left作为主要控制点，确保遍历了数组每个元素，right用于找到每个连续 1 的子序列的结束位置
+        while (left < n) {//最多执行 n 次，因此是 O(n) left
+            // Find the first occurrence of 1 starting from  
+            if (nums[left] != 1) {
+                left++;
+            } else {
+                // Move right pointer from left until nums[right] != 1 or end of array
+                right = left;
+                // 最多执行 n 次，因此是 O(n)
+                while (right < n && nums[right] == 1) {
+                    right++;
+                }
+                // Update maxCount with the length of the consecutive ones found
+                maxCount = Math.max(maxCount, right - left);
+                // Update left to the new position of right
+                left = right;
+            }
+        }
+        return maxCount;
+    }
+}
+//while循环取条件里的最高复杂度
+
+// @lc code=end
+

lcJava/Array and String Topics/35.search-insert-position.java

@@ -0,0 +1,35 @@
+/*
+ * @lc app=leetcode id=485 lang=java
+ *
+ * [485] Max Consecutive Ones
+ */
+
+// @lc code=start
+class Solution {
+    public int findMaxConsecutiveOnes(int[] nums) {
+        int count = 0;
+        int maxCount = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] == 1) {
+                count++;
+            } else {
+                // when a non-1 element is encoutered, compare the count of 1s with the current
+                // maxCount
+                // set the count for the track of the next sequence of 1s
+
+                maxCount = Math.max(maxCount, count);
+                count = 0;
+
+            }
+        }
+        // if the iteration if completed by a 1s sequence, the count will not be
+        // comapred to maxCount in the 'else'
+        // we need to do it again here
+        maxCount = Math.max(maxCount, count);
+        return maxCount;
+    }
+}
+// Greedy + one pass(O(n))
+
+// @lc code=end
+