初级算法49题 — LeetCode（20181122 - ）

Array：

Single Number

 class Solution {
     public int singleNumber(int[] nums) {
         if (nums == null || nums.length == 0) {
             return 0;
         }
         int res = nums[0];
         for (int i = 1; i < nums.length; i++) {
             res = res ^ nums[i];
         }

         return res;
     }
 }

Remove Duplicates from Sorted Array

 class Solution {
     public int removeDuplicates(int[] nums) {
         if(nums==null || nums.length==0){
             return 0;
         }
         int res =1;
         for(int i=1;i<nums.length;i++){
             if(nums[i]!=nums[i-1]){
                 nums[res] = nums[i];
                 res++;
             }
         }
         return res;
     }
 }

Best Time to Buy and Sell Stock II

 class Solution {
     public int maxProfit(int[] prices) {
         if (prices == null || prices.length == 0) {
             return 0;
         }
         int res = 0;
         for (int i = 0; i < prices.length - 1; i++) {
             if (prices[i + 1] - prices[i] > 0) {
                 res += prices[i + 1] - prices[i];
             }
         }
         return res;
     }
 }

Rotate Array

这题注意处理k>nums.length的情况，直接取余

 class Solution {
     public void rotate(int[] nums, int k) {
         if (nums == null || nums.length == 0) {
             return;
         }
         k = k%nums.length;
         rotateSubArray(nums, 0, nums.length - k - 1);
         rotateSubArray(nums, nums.length - k, nums.length - 1);
         rotateSubArray(nums, 0, nums.length - 1);
     }

     public void rotateSubArray(int[] nums, int start, int end) {
         int left = start;
         int right = end;
         while (left < right) {
             swap(nums, left, right);
             left++;
             right--;
         }
     }

     public void swap(int[] nums, int aIndex, int bIndex) {
         int temp = nums[aIndex];
         nums[aIndex] = nums[bIndex];
         nums[bIndex] = temp;
     }
 }

Contains Duplicate

 class Solution {
     public boolean containsDuplicate(int[] nums) {
         if (nums == null || nums.length == 0) {
             return false;
         }

         Arrays.sort(nums);
         for (int i = 0; i < nums.length - 1; i++) {
             if (nums[i] == nums[i + 1])
                 return true;
         }

         return false;
     }
 }

 Intersection of Two Arrays II

 class Solution {
     public int[] intersect(int[] nums1, int[] nums2) {
         if (nums1 == null || nums1.length == 0) {
             return nums1;
         }

         if (nums2 == null || nums2.length == 0) {
             return nums2;
         }
         List<Integer> list = new ArrayList<>();
         HashMap<Integer, Integer> map = new HashMap<>();
         for (int num : nums1) {
             if (map.get(num) == null) {
                 map.put(num, 1);
             } else {
                 map.put(num, map.get(num) + 1);
             }
         }

         for (int num : nums2) {
             Integer exist = map.get(num);
             if (exist != null && exist > 0) {
                 map.put(num, exist - 1);
                 list.add(num);
             }
         }

         int[] res = new int[list.size()];
         for (int i = 0; i < res.length; i++) {
             res[i] = list.get(i);
         }
         return res;
     }
 }

Plus One

注意当结果为1000...时需重新生成长数组返回，否则WA(eg：99999 -> 00000)

 class Solution {
     public int[] plusOne(int[] digits) {
         if (digits == null || digits.length == 0) {
             return digits;
         }

         int carry = digits[digits.length - 1] + 1 >= 10 ? 1 : 0;
         digits[digits.length - 1] = carry == 1 ? 0 : digits[digits.length - 1] + 1;
         if (carry == 0) {
             return digits;
         }
         for (int i = digits.length - 2; i >= 0; i--) {
             if (digits[i] + carry >= 10) {
                 digits[i] = 0;
             } else {
                 digits[i] = digits[i] + carry;
                 return digits;
             }
         }

         int[] newNumber = new int[digits.length+1];
         newNumber[0] = 1;
         return newNumber;
     }
 }

Move Zeroes

 class Solution {
     public void moveZeroes(int[] nums) {
         if (nums == null || nums.length == 0) {
             return;
         }

         int noZeroIndex = 0;
         for (int i = 0; i < nums.length; i++) {
             if (nums[i] != 0) {
                 nums[noZeroIndex] = nums[i];
                 noZeroIndex++;
             }
         }

         for (int j = noZeroIndex; j < nums.length; j++) {
             nums[j] = 0;
         }

         return;
     }
 }

Two Sum

 class Solution {
     public int[] twoSum(int[] nums, int target) {
         if (nums == null || nums.length < 2) {
             return null;
         }

         Map<Integer, Integer> map = new HashMap<>();
         for (int i = 0; i < nums.length; i++) {
             Integer exist = map.get(target - nums[i]);
             if (exist != null) {
                 int[] res = new int[2];
                 res[0] = i;
                 res[1] = exist;
                 return res;
             }
             map.put(nums[i], i);
         }

         return null;
     }
 }

Strings

Reverse String

 class Solution {
     public String reverseString(String s) {
         if (s == null || s.length() == 0) {
             return s;
         }
         char[] arrays = s.toCharArray();
         int start = 0;
         int end = arrays.length - 1;
         while (start < end) {
             char temp = arrays[start];
             arrays[start] = arrays[end];
             arrays[end] = temp;
             start++;
             end--;
         }

         return new String(arrays);
     }
 }

Reverse Integer

 class Solution {
     public int reverse(int x) {
         String s = x + "";
         if (s.length() <= 1) {
             return x;
         }
         char[] arrays = s.toCharArray();
         int len = arrays.length;
         int start = 0;
         int end = s.length() - 1;
         while (start < arrays.length && arrays[start] > '9' || arrays[start] < '0') {
             start++;
         }
         while (end >= 0 && arrays[end] == '0') {
             arrays[end] = ' ';
             end--;
         }
         while (start < end) {
             char temp = arrays[start];
             arrays[start] = arrays[end];
             arrays[end] = temp;
             start++;
             end--;
         }

         s = new String(arrays);
         Long res = Long.valueOf(s.trim());
         if (res > Integer.MAX_VALUE || res < Integer.MIN_VALUE) {
             return 0;
         }
         return res.intValue();
     }
 }

 First Unique Character in a String

 class Solution {
     public int firstUniqChar(String s) {
         if (s == null || s.length() == 0) {
             return -1;
         }

         char[] array = s.toCharArray();
         Map<Character, Integer> map = new HashMap<>();
         for (int i = 0; i < array.length; i++) {
             Integer exist = map.get(array[i]);
             if (exist == null) {
                 map.put(array[i], 1);
             } else {
                 map.put(array[i], exist + 1);
             }
         }

         for (int i = 0; i < array.length; i++) {
             if (map.get(array[i]) == 1) {
                 return i;
             }
         }
         return -1;
     }
 }

Valid Palindrome

 class Solution {
     public boolean isPalindrome(String s) {
         if (s == null || s.length() == 0) {
             return true;
         }
         s = s.trim();
         int start = 0;
         int end = s.length() - 1;
         while (start < end) {
             while (start < s.length() && !Character.isLetter(s.charAt(start)) && !Character.isDigit(s.charAt(start))) {
                 start++;
             }

             while (end >= 0 && !Character.isLetter(s.charAt(end)) && !Character.isDigit(s.charAt(end))) {
                 end--;
             }
             if (start >= end) {
                 break;
             }
             if (Character.toLowerCase(s.charAt(start)) != Character.toLowerCase(s.charAt(end))) {
                 return false;
             }
             start++;
             end--;
         }

         return true;
     }
 }