双指针 — 20180928 - 20181012

Posted 2021-01-12 lizzyluvcoding

同向双指针：

100. Remove Duplicates from Sorted Array

1  public  class Solution {
 2      /* 
3       * @param nums: An ineger array
 4       * @return: An integer
 5       */ 
6      public  int removeDuplicates( int [] nums) {
 7          // write your code here 
8          
9          if (nums == null ||nums.length ==0 ){
 10              return 0 ;
 11          }
 12          
13          int index=0 ;
 14          for ( int i=0; i<nums.length;i++){
 15              if (i==0 || nums[i]!=nums[i-1 ]){
 16                  nums[index]= nums[i];
 17                  index++ ;
 18              }
 19          }
 20          
21          return index;
 22      }
 23 }

View Code

 

539. Move Zeroes

 1 public class Solution {
 2     /**
 3      * @param nums: an integer array
 4      * @return: nothing
 5      */
 6     public void moveZeroes(int[] nums) {
 7         // write your code here
 8         if (nums == null || nums.length == 0) {
 9             return;
10         }
11 
12         int zeroIndex = 0;
13         int numIndex = 0;
14         while (zeroIndex < nums.length) {
15             if (nums[zeroIndex] != 0) {
16                 swap(nums, zeroIndex, numIndex);
17                 numIndex++;
18             }
19             zeroIndex++;
20         }
21     }
22 
23     public void swap(int[] num, int left, int right) {
24         int temp = num[left];
25         num[left] = num[right];
26         num[right] = temp;
 27      }
 28 }

View Code

 

604. Window Sum

 1 public class Solution {
 2     /**
 3      * @param nums: a list of integers.
 4      * @param k:    length of window.
 5      * @return: the sum of the element inside the window at each moving.
 6      */
 7     public int[] winSum(int[] nums, int k) {
 8         // write your code here
 9         if (nums == null || nums.length == 0 || k > nums.length) {
10             return new int[0];
11         }
12 
13         int len = nums.length - k + 1;
14         int[] res = new int[len];
15 
16         for (int i = 0; i < k; i++) {
17             res[0] += nums[i];
18         }
19 
20         for (int j = 1; j < res.length; j++) {
21             res[j] = res[j - 1] - nums[j - 1] + nums[j + k - 1];
22         }
23         return res;
24     }
25 }

View Code

 

相向双指针：

415. Valid Palindrome

 1 public class Solution {
 2     /**
 3      * @param s: A string
 4      * @return: Whether the string is a valid palindrome
 5      */
 6     public boolean isPalindrome(String s) {
 7         // write your code here
 8         if (s == null || s.length() == 0) {
 9             return true;
10         }
11 
12         int start = 0;
13         int end = s.length() - 1;
14         while (start < end) {
15             while (start < end && !isCharacter(s.charAt(start))) {
16                 start++;
17             }
18 
19             while (start < end && !isCharacter(s.charAt(end))) {
20                 end--;
21             }
22 
23             if (Character.toLowerCase(s.charAt(start)) != Character.toLowerCase(s.charAt(end))) {
24                 return false;
25             }
26             start++;
27             end--;
28         }
29         return true;
30     }
31 
32     public boolean isCharacter(char c) {
33         return Character.isLetter(c) || Character.isDigit(c);
34     }
35 }

View Code

 

8. Rotate String

三步翻转

 1 public class Solution {
 2     /**
 3      * @param str:    An array of char
 4      * @param offset: An integer
 5      * @return: nothing
 6      */
 7     public void rotateString(char[] str, int offset) {
 8         // write your code here
 9         if (str == null || str.length == 0 || offset == 0) {
10             return;
11         }
12 
13         int k = offset % str.length;
14         reverse(str, 0, str.length - k - 1);
15         reverse(str, str.length - k, str.length-1);
16         reverse(str, 0, str.length - 1);
17         return;
18     }
19 
20     public void reverse(char[] str, int start, int end) {
21         while (start < end) {
22             char temp = str[start];
23             str[start] = str[end];
24             str[end] = temp;
25             start++;
26             end--;
27         }
28     }
29 }

View Code

 

39. Recover Rotated Sorted Array

找到翻转点，思路同上

 1 public class Solution {
 2     /**
 3      * @param nums: An integer array
 4      * @return: nothing
 5      */
 6     public void recoverRotatedSortedArray(List<Integer> nums) {
 7         // write your code here
 8         if (nums == null || nums.size() == 0) {
 9             return;
10         }
11         for (int i = 0; i < nums.size() - 1; i++) {
12             if (nums.get(i) > nums.get(i + 1)) {
13                 reverse(nums, 0, i);
14                 reverse(nums, i + 1, nums.size() - 1);
15                 reverse(nums, 0, nums.size() - 1);
16                 return;
17             }
18         }
19 
20     }
21 
22     public void reverse(List<Integer> nums, int start, int end) {
23         while (start < end) {
24             int temp = nums.get(start);
25             nums.set(start, nums.get(end));
26             nums.set(end, temp);
27             start++;
28             end--;
29         }
30     }
31 }

View Code

 

607. Two Sum III - Data structure design

 1 public class TwoSum {
 2     /**
 3      * @param number: An integer
 4      * @return: nothing
 5      */
 6     private Map<Integer, Integer> map = new HashMap<>();
 7 
 8     public void add(int number) {
 9         // write your code here
10         if (map.containsKey(number)) {
11             map.put(number, map.get(number) + 1);
12             return;
13         }
14         map.put(number, 1);
15     }
16 
17     /**
18      * @param value: An integer
19      * @return: Find if there exists any pair of numbers which sum is equal to the value.
20      */
21     public boolean find(int value) {
22         // write your code here
23         for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
24             if (value - entry.getKey() == entry.getKey()) {
25                 if (entry.getValue() > 1) {
26                     return true;
27                 }
28                 continue;
29             }
30             Integer targetIndex = map.get(value - entry.getKey());
31             if (targetIndex != null) {
32                 return true;
33             }
34         }
35         return false;
36     }
37 }

View Code

 

608. Two Sum II - Input array is sorted

 1 public class Solution {
 2     /**
 3      * @param nums:   an array of Integer
 4      * @param target: target = nums[index1] + nums[index2]
 5      * @return: [index1 + 1, index2 + 1] (index1 < index2)
 6      */
 7     public int[] twoSum(int[] nums, int target) {
 8         // write your code here
 9         int[] res = new int[2];
10         if (nums == null || nums.length == 0) {
11             return res;
12         }
13         int start = 0;
14         int end = nums.length - 1;
15         while (start < end) {
16             int sum = nums[start] + nums[end];
17             if (sum == target) {
18                 res[0] = start + 1;
19                 res[1] = end + 1;
20                 return res;
21             }
22             if (sum > target) {
23                 end--;
24             }
25             if (sum < target) {
26                 start++;
27             }
28         }
29         return res;
30     }
31 }

View Code

 

587. Two Sum - Unique pairs

 1 public class Solution {
 2     public int twoSum(int[] nums, int target) {
 3         // write your code here
 4         if (nums == null || nums.length == 0) {
 5             return 0;
 6         }
 7         Arrays.sort(nums);
 8         int start = 0;
 9         int end = nums.length - 1;
10         int count = 0;
11         while (start < end) {
12             int sum = nums[start] + nums[end];
13             if (sum == target) {
14                 count++;
15                 start++;
16                 end--;
17                 while (start < end && nums[start] == nums[start - 1]) start++;
18                 while (start < end && nums[end] == nums[end + 1]) end--;
19             }
20             if (sum > target) {
21                 end--;
22             }
23             if (sum < target) {
24                 start++;
25             }
26         }
27         return count;
28     }
29 }

View Code

 

57. 3Sum

 1 public class Solution {
 2     /**
 3      * @param numbers: Give an array numbers of n integer
 4      * @return: Find all unique triplets in the array which gives the sum of zero.
 5      */
 6     public List<List<Integer>> threeSum(int[] numbers) {
 7         // write your code here
 8         List<List<Integer>> res = new ArrayList<>();
 9         if (numbers == null || numbers.length < 3) {
10             return res;
11         }
12 
13         Arrays.sort(numbers);
14         for (int i = 0; i < numbers.length - 2; i++) {
15             if (i > 0 && numbers[i] == numbers[i - 1]) continue;
16             towSum(numbers, i + 1, numbers.length - 1, 0 - numbers[i], res);
17         }
18         return res;
19     }
20 
21     public void towSum(int[] numbers, int start, int end, int target, List<List<Integer>> res) {
22         while (start < end) {
23             int sum = numbers[start] + numbers[end];
24             if (sum == target) {
25                 List<Integer> pair = new ArrayList<>();
26                 pair.add(-target);
27                 pair.add(numbers[start]);
28                 pair.add(numbers[end]);
29                 res.add(pair);
30                 start++;
31                 end--;
32                 while (start < end && numbers[start] == numbers[start - 1]) start++;
33                 while (start < end && numbers[end] == numbers[end + 1]) end--;
34             }
35             if (sum > target) {
36                 end--;
37             }
38             if (sum < target) {
39                 start++;
40             }
41 
42         }
43     }
44 
45 }

View Code

 

382. Triangle Count

 1 public class Solution {
 2     /**
 3      * @param S: A list of integers
 4      * @return: An integer
 5      */
 6     public int triangleCount(int[] S) {
 7         // write your code here
 8         if (S == null || S.length < 3) {
 9             return 0;
10         }
11         Arrays.sort(S);
12         int count = 0;
13         for (int i = 2; i < S.length; i++) {
14             int left = 0;
15             int right = i - 1;
16             while (left < right) {
17                 int sum = S[left] + S[right];
18                 if (sum > S[i]) {
19                     count += right - left;
20                     right--;
21                 }
22                 if (sum <= S[i]) {
23                     left++;
24                 }
25             }
26         }
27 
28         return count;
29     }
30 }

View Code

 

59. 3Sum Closest

 1 public class Solution {
 2     /**
 3      * @param numbers: Give an array numbers of n integer
 4      * @param target:  An integer
 5      * @return: return the sum of the three integers, the sum closest target.
 6      */
 7     public int threeSumClosest(int[] numbers, int target) {
 8         // write your code here
 9         if (numbers == null || numbers.length < 3) {
10             return 0;
11         }
12         Arrays.sort(numbers);
13         int res = numbers[0] + numbers[1] + numbers[2];
14         for (int i = 0; i < numbers.length; i++) {
15             int start = i + 1;
16             int end = numbers.length - 1;
17             int num = numbers[i];
18             while (start < end) {
19                 int sum = numbers[start] + numbers[end] + num;
20                 if (Math.abs(sum - target) < Math.abs(res - target)) {
21                     res = sum;
22                 }
23                 if (sum == target) {
24                     return target;
25                 }
26                 if (sum > target) {
27                     end--;
28                 }
29                 if (sum < target) {
30                     start++;
31                 }
32             }
33         }
34         return res;
35     }
36 
37 }

View Code

 

31.  Partition Array(需重刷)

 1 public class Solution {
 2     /** 
 3      *@param nums: The integer array you should partition
 4      *@param k: As description
 5      *return: The index after partition
 6      */
 7     public int partitionArray(int[] nums, int k) {
 8         if(nums == null || nums.length == 0){
 9             return 0;
10         }
11         
12         int left = 0, right = nums.length - 1;
13         while (left <= right) {
14 
15             while (left <= right && nums[left] < k) {
16                 left++;
17             }
18 
19             while (left <= right && nums[right] >= k) {
20                 right--;
21             }
22 
23             if (left <= right) {
24                 int temp = nums[left];
25                 nums[left] = nums[right];
26                 nums[right] = temp;
27                 
28                 left++;
29                 right--;
30             }
31         }
32         return left;
33     }
34 }

View Code

 

373. Partition Array by Odd and Even

 1 public class Solution {
 2     /*
 3      * @param nums: an array of integers
 4      * @return: nothing
 5      */
 6     public void partitionArray(int[] nums) {
 7         // write your code here
 8         if (nums == null || nums.length == 0) {
 9             return;
10         }
11         int left = 0;
12         int right = nums.length - 1;
13 
14         while (left <= right) {
15             while (left <= right && nums[left] % 2 == 1) {
16                 left++;
17             }
18 
19             while (left <= right && nums[right] % 2 == 0) {
20                 right--;
21             }
22             if (left <= right) {
23                 int temp = nums[left];
24                 nums[left] = nums[right];
25                 nums[right] = temp;
26                 left++;
27                 right--;
28             }
29         }
30         return;
31 
32     }
33 }

View Code

 

49. Sort Letters by Case

 1 public class Solution {
 2     /*
 3      * @param chars: The letter array you should sort by Case
 4      * @return: nothing
 5      */
 6     public void sortLetters(char[] chars) {
 7         // write your code here
 8         if (chars == null || chars.length == 0) {
 9             return;
10         }
11 
12         int start = 0;
13         int end = chars.length - 1;
14         while (start <= end) {
15             while (start <= end && Character.isLowerCase(chars[start])) start++;
16             while (start <= end && !Character.isLowerCase(chars[end])) end--;
17             if (start <= end) {
18                 char temp = chars[start];
19                 chars[start] = chars[end];
20                 chars[end] = temp;
21                 start++;
22                 end--;
23             }
24         }
25         return;
26     }
27 }

View Code

 

148. Sort Colors

 1 public class Solution {
 2     /**
 3      * @param nums: A list of integer which is 0, 1 or 2
 4      * @return: nothing
 5      */
 6     public void sortColors(int[] nums) {
 7         // write your code here
 8         if (nums == null || nums.length == 0) return;
 9 
10         int left = 0;
11         int right = nums.length - 1;
12         int i = 0;
13 
14         while (i <= right) {
15             if (nums[i] == 0) {
16                 int temp = nums[i];
17                 nums[i] = nums[left];
18                 nums[left] = temp;
19                 left++;
20                 i++;
21             }
22             else if (nums[i] == 1) {
23                 i++;
24             }
25             else {
26                 int temp = nums[i];
27                 nums[i] = nums[right];
28                 nums[right] = temp;
29                 right--;
30             }
31         }
32         return;
33     }
34 }

View Code

 

143. Sort Colors II（148的FollowUp）快排和归并排序的结合

 1 public class Solution {
 2     /**
 3      * @param colors: A list of integer
 4      * @param k:      An integer
 5      * @return: nothing
 6      */
 7     public void sortColors2(int[] colors, int k) {
 8         // write your code here
 9         if (colors == null || colors.length == 0 || k > colors.length) {
10             return;
11         }
12 
13         partitionColor(colors, 0, colors.length - 1, 0, k);
14     }
15 
16     //start-end 排序的数组起始下标
17     //colorFrom-colorTo 这一段的颜色
18     public void partitionColor(int[] colors, int startIndex, int endIndex, int colorFrom, int colorTo) {
19         if (colorFrom == colorTo)
20             return;
21         if (startIndex > endIndex) {
22             return;
23         }
24         int left = startIndex;
25         int right = endIndex;
26         //划分的颜色
27         int colorMid = colorFrom + (colorTo - colorFrom) / 2;
28         while (left <= right) {
29             while (left <= right && colors[left] <= colorMid) left++;
30             while (left <= right && colors[right] > colorMid) right--;
31             if (left <= right) {
32                 int temp = colors[left];
33                 colors[left] = colors[right];
34                 colors[right] = temp;
35                 left++;
36                 right--;
37             }
38         }
39         partitionColor(colors, startIndex, right, colorFrom, colorMid);
40         partitionColor(colors, left, endIndex, colorMid + 1, colorTo);
41     }
42 }

View Code