LeetCode: Tags-[Array], Difficulty-[Easy]

Tags: Array

Difficulty：Easy

1. Two Sum:https://leetcode.com/problems/two-sum/

两数和,返回下标数组:(利用HashMap<Key,Value>遍历，其中用到containKey,get(key)--获取value; put<,>;)

<HashMap><Two Pointers>

(1.HashMap,rst; 2.for() / if(containsKey(tar-num[i]))num[1]get/[0]i,return / put();  3.return)

(有时候题目要求返回数组是基1的,所以是key对于的value都改成i+1了)

public class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        int[] rst = new int[2];
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(target - nums[i])){
                rst[1] = i;
                rst[0] = map.get(target - nums[i]);
                return rst;
            }
            map.put(nums[i],i);
        }
        return rst;
    }
}

26. Remove Duplicates from Sorted Array: https://leetcode.com/problems/remove-duplicates-from-sorted-array/

 移除已排序数组的重复元素：<Two Pointers> (指针1遍历，指针2指向'新'数组，如果指针1所指和指针2所指不同则加入，否则跳过。注意:nums[++rst]不能写成nums[rst+1],不然指针没有增长！)

(1.if  2.for()if(rst!i)[++rst],return rst+1;)

public class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums == null || nums.length == 0 ){
            return 0;
        }
        int rst = 0;
        for (Integer num : nums) {
            if (num != nums[rst]) {
                nums[++rst] = num;
            }
        }
        return rst + 1;
    }
}

27. Remove Element: https://leetcode.com/problems/remove-element/

移除指定数字：<Two Pointers>

我的解法：(依然是指针1遍历，指针2指向新数组；与指定值不同则加入) 缺点，第一个需要move的元素 后面所有元素都要move；

(1.if  2.for()if(i!val)[rst++],return rst;) 

public class Solution {
    public int removeElement(int[] nums, int val) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int rst = 0;
        for (int i = 0; i < nums.length; i++) {
            if ( nums[i] != val ) {
                nums[rst++] = nums[i]; 
            }
        }
        return rst;
    }
}

其他解法：(由于题目中说：可以改变元素顺序；考虑移动更少的不数--two pointers从两头往中间走; 为了使i遍历到所有数,while的条件是i<=p,这样最后i=p=last number 如果是val,p--;如果不是val,p;总之rst都是p+1)

(1.i,pointer 2.while(i<=p) if(=)swap,--; else++; return pointer+1)

public class Solution {
    public int removeElement(int[] A, int elem) {
        int i = 0;
        int pointer = A.length - 1;
        while(i <= pointer){
            if(A[i] == elem){
                A[i] = A[pointer];
                pointer--;
            } else {
                i++;
            }
        }
        return pointer + 1;
    }
}

↑ 示例：[3,2,3,4,2,5,2]->[3,5,3,4] (过程:先add3,remove2,同时pointer指向的2swap到前面,pointer--;再判断remove2,……)

66. Plus One: https://leetcode.com/problems/plus-one/

数组加一：(常规情况：尾数加1，有9进位；特殊情况，都为9，则数组加一。解法：1.判断末位是否小于9,小于则加1return;2.否则置零判断前一位 循环；3.都为9，则需要添加以为1在首位)

(1.for(n-1,>=0) if(<)++return,[]=0;  2.new int[n+1] [0]=1 return new;)

public class Solution {
    public int[] plusOne(int[] digits) {
        int n = digits.length;
        for (int i = n - 1; i >= 0; i--) {
            if (digits[i] < 9) {
                digits[i]++;
                return digits;
            }
            digits[i] = 0;
        }
        int[] specialCase = new int[n+1];
        specialCase[0] = 1;
        return specialCase;
    }
}

88. Merge Sorted Array: https://leetcode.com/problems/merge-sorted-array/

合并两个有序数组：

解法1：(插入排序思想，需要注意的是指针的变化)

(1.for(j),i,tar; 2.for(i m+j, >tar,--)[i][i-1]; 3.[i]=tar);

public class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        for (int j = 0; j < n; j++) {
            int i;
            int tar = nums2[j];
            for (i = m + j; i > 0 && nums1[i - 1] > tar; i--) {
                nums1[i] = nums1[i - 1] ;
            }
            nums1[i] = tar;
        }
    }
}

解法2：(从后向前遍历，大的数插入A数组末尾，3pointers;如果最后nums1已经插完，那么剩下的都是nums2)

(1.i,j,index  2.while(>=0)if(>)([--])else  3.while(j>=0))

public class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int i = m - 1;
        int j = n - 1;
        int index = m + n - 1;
        while (i >= 0 && j >= 0) {
            if (nums1[i] > nums2[j]) {
                nums1[index--] = nums1[i--];
            } else {
                nums1[index--] = nums2[j--];
            }
        }
        while (j >= 0) {
            nums1[index--] = nums2[j--];
        }
    }
}

118. Pascal's Triangle: https://leetcode.com/problems/pascals-triangle/

 帕斯卡三角：

解法1：(在上一行添加一位1；在计算set(j,[j][j+1]))

public class Solution {
public List<List<Integer>> generate(int numRows)
{
    List<List<Integer>> allrows = new ArrayList<List<Integer>>();
    ArrayList<Integer> row = new ArrayList<Integer>();
    for(int i=0;i<numRows;i++)
    {
        row.add(0, 1);
        for(int j=1;j<row.size()-1;j++)
            row.set(j, row.get(j)+row.get(j+1));
        allrows.add(new ArrayList<Integer>(row));
    }
    return allrows;
    
}

解法2：(直接添加每行的数字)

public class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> rst = new ArrayList<List<Integer>>();
        for (int i = 0; i < numRows; i++) {
            List<Integer> row = new ArrayList<Integer>();
            for (int j = 0; j < i + 1; j++) {
                if (j == 0 || j == i) {
                    row.add(1);
                } else {
                row.add(rst.get(i - 1).get(j - 1) + rst.get(i - 1).get(j));
                }
            }
            rst.add(row);
        }
        return rst;
    }
}

119. Pascal's Triangle II: https://leetcode.com/problems/pascals-triangle-ii/

求第K行帕斯卡三角：要求O(k)space;

我的解法：递归

public class Solution {
    public List<Integer> getRow(int rowIndex) {
        List<Integer> rst = new ArrayList<Integer>();
        if (rowIndex == 0) {
            rst.add(1);
            return rst;
        }
        rst = getRow(rowIndex - 1);
        rst.add(0,1);
        for (int i = 1; i < rowIndex; i++) {
            rst.set(i,rst.get(i) + rst.get(i + 1));
        }
        return rst;
    }
}

其他解法：(for循环遍历)

  public List<Integer> getRow(int rowIndex) {
    List<Integer> list = new ArrayList<Integer>();
    if (rowIndex < 0)
        return list;

    for (int i = 0; i < rowIndex + 1; i++) {
        list.add(0, 1);
        for (int j = 1; j < list.size() - 1; j++) {
            list.set(j, list.get(j) + list.get(j + 1));
        }
    }
    return list;
}

121. Best Time to Buy and Sell Stock: https://leetcode.com/problems/best-time-to-buy-and-sell-stock/

买卖股票：

我的解法：(Time Limit Exceeded；两个for循环，外循环遍历，内循环求i-n的max, 判断maxPro；嵌套思想：max=Math.max(max,[j]) maxPro=Math.max(maxPro,max-[i]); LeetCode最后一组大数据超时不通过，LintCode可以通过……)

public class Solution {
    public int maxProfit(int[] prices) {
        int maxPro = 0;
        for (int i = 0; i < prices.length - 1; i++) {
            int j;
            int max = 0;
            for (j = i + 1; j <prices.length; j++) {
                max = Math.max(max,prices[j]);
            }
            if (max > prices[i]) {
                maxPro = Math.max(maxPro,max - prices[i]);
            }
        }
        return maxPro;
    }
}

解法：(一次遍历，min记录至今的最小值, maxPro记录至今的最大profit；比较min和price,小于min，那么min易值；大于min那么比较maxPro和price-min的大小)

(1.min,maxPro; 2.for(int) if(<) else(maxPro=Math.max()); 3.return)

public class Solution {
    public int maxProfit(int[] prices) {
        int maxPro = 0;
        int min =Integer.MAX_VALUE;
        for (int price: prices) {
            if (price < min) {
                min = price;
            } else {
                maxPro = Math.max(maxPro, price - min);
            }
        }
        return maxPro;
    }
}

169. Majority Element: https://leetcode.com/problems/majority-element/

出现次数超过n/2的数：

我的解法：(HashMap<num[i],cnt>;cnt>n/2时return;contains那么cnt++,否则初始化put(,1)；  涉及方法:containsKey(), get()--get value, put(Key,value)--可以覆盖)

public class Solution {
    public int majorityElement(int[] nums) {
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        int majorityElement = 0;
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
                int tmp = map.get(nums[i]);
                map.put(nums[i],++tmp);
            } else {
                map.put(nums[i],1);
            }
            if (map.get(nums[i]) > nums.length/2){
                majorityElement = nums[i];
                return majorityElement;
            }
        }
        return majorityElement;
    }
}

另一个人的HashMap,参考下：

public class Solution {
    public int majorityElement(int[] nums) {
        int L = nums.length;
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int i=0; i<L; i++) {
            if(map.containsKey(nums[i])) {
                if(map.get(nums[i]) >= L/2)
                    return nums[i];
                map.replace(nums[i], map.get(nums[i])+1);
            }
            else
                map.put(nums[i], 1);
        }
        return nums[L-1];
    }
}

 

解法2：(sort排序m，return[n/2];)

public class Solution {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        int len = nums.length;
        return nums[len/2];
    }
}

解法3：(O(n)timeO(1)space,指针移动，正负计数；most votes of LeetCode)

public class Solution {
    public int majorityElement(int[] num) {

        int major=num[0], count = 1;
        for(int i=1; i<num.length;i++){
            if(count==0){
                count++;
                major=num[i];
            }else if(major==num[i]){
                count++;
            }else count--;
            
        }
        return major;
    }
}

189. Rotate Array: https://leetcode.com/problems/rotate-array/

向右旋转字符串：

我的解法：(step=k%n; Copy数组，分为两部分改变字符串，前半部分是[i]=[n-step+i]，后半部分是[i]=[i-step])(ps:LeetCode有时提交会TLE，有时不会。数据太多的时候耗时多)

(1.n,tmp[],step; 2.if()return; 3.System.arraycopy(); 4.for(0,step)[][n-ste+i]; 5.for(step,n)[][i-step] ;)

public class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        int[] tmp = new int[n];
        int step = k%n;
        if (nums.length == 0 || step == 0) {
            return;
        }
        System.arraycopy(nums,0,tmp,0,n);
        for (int i = 0; i < step; i++) {
            nums[i] = tmp[n - step + i];
        }
        for (int i = step; i < n; i++) {
            nums[i] = tmp[i - step];
        }
    }
}

 相似解法：(tmp[]存储[step]的值 O(n) time cost, O(k % nums.length) space cost)

public class Solution {
    public void rotate(int[] nums, int k) {
        if(nums.length <= 1){
            return;
        }
        //step each time to move
        int step = k % nums.length;
        int[] tmp = new int[step];
        for(int i = 0; i < step; i++){
            tmp[i] = nums[nums.length - step + i];
        }
        for(int i = nums.length - step - 1; i >= 0; i--){
            nums[i + step] = nums[i];
        }
        for(int i = 0; i < step; i++){
            nums[i] = tmp[i];
        }     
    }
}

原地解法：(定义reverse方法;1.全部反转 2.反转(0,k-1)部分 3.反转(k,n-1))

public class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        k %= n;
        reverse(nums, 0, n - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, n - 1);
    }
    public void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int tmp = nums[end];
            nums[end] = nums[start];
            nums[start] = tmp;
            start++; end--;
        }
    }
}

217. Contains Duplicate: https://leetcode.com/problems/contains-duplicate/

判断数组是否包含重复元素：<HashMap>

我的解法：<HashMap> (O(n),O(n)其实不用HashMap,HashSet即可。补全知识点！)

(1.map; 2.for() if(containsKey()) return;add  3.return false;)

public class Solution {
    public boolean containsDuplicate(int[] nums) {
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for (int i = 0; i < nums.length; i++){
            if (map.containsKey(nums[i])){
                return true;
            }
            map.put(nums[i],i);
        }
        return false;
    }
}

解法2：(Set，利用Set的不重复性，add--if重复，则return false)(PS:TLE)

public class Solution {
    public  boolean containsDuplicate(int[] nums) {
         Set<Integer> set = new HashSet<Integer>();
         for(int i : nums)
             if(!set.add(i))// if there is same
                 return true; 
         return false;
     }
}

解法3：(先sort, 再判断连续重复问题 O(nlgn),O(1))

public class Solution {
    public boolean containsDuplicate(int[] nums) {

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

解法4：(用HashSet改进了我的解法1)  (有时AC有时最后的大数据TLE，搞不懂LeetCode判定方法……)

public class Solution {
    public boolean containsDuplicate(int[] nums) {

        Set<Integer> distinct = new HashSet<Integer>();
        for(int num : nums) {
            if(distinct.contains(num)) {
                return true;
            }
            distinct.add(num);
        }
        return false;
    }
}

219. Contains Duplicate II:https://leetcode.com/problems/contains-duplicate-ii/

判断是否有重复数字且间隔不大于指定值:

我的解法：<HashMap>(如果已经包含了，那么判断间隔是否小于等于k；如果不包含，put；如果包含了但间隔大于k，那么put覆盖；两种情况可以统一写在if语句外)

(1.map;  2.for() if(containsKey&&<=)return;  3.put;  4.return)  (PS: Bug Free！ 一次性Accepted)

public class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i]) && (i - map.get(nums[i]) <= k)) {
                    return true;
            }
            map.put(nums[i],i);
        }
        return false;
    }
}

解法2：<HashSet sliding window>(利用长度为k+1的滑动窗口遍历数组；if(i>k)-当开始遍历到大于k+1长度的数字是,每次要remove掉首位;  if(!add))true利用set的不重复性；PS:判断语句if()里的add也能执行……)

(1.set; 2.for(0,n) if(>)remove[i-k-1]; 3.if(!add)true 4.false)

public class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        Set<Integer> set = new HashSet<Integer>();
        for (int i = 0; i < nums.length; i++) {
            if (i > k) set.remove(nums[i - k - 1]);
            if (!set.add(nums[i])) return true;
        }
        return false;
    }
}

283. Move Zeroes: https://leetcode.com/problems/move-zeroes/

将0移到最后:(i移动遍历，j指向第一个零，遍历到不为零的，则与第一个零调换)

(for if(!=)swap,j++)

public class Solution {
    public void moveZeroes(int[] nums) {
        int j = 0;
        for(int i = 0; i < nums.length; i++) {
            if(nums[i] != 0) {
                int temp = nums[j];
                nums[j] = nums[i];
                nums[i] = temp;
                j++;
            }
        }
    }
}

414. Third Maximum Number: https://leetcode.com/problems/third-maximum-number/

返回第三大的数,如果不存在,返回max: 

我的解法：<HashMap> (先将数组排序，然后利用containsValue()，put(index++,num)将不重复的数字放入map中，index对应num的大小顺序；因为最后涉及取出指，所以index作为key，num作为value；不用HashSet，因为HashSet无序，没法取出第三大的数) (PS:运行时间特别长……题目要求是O(n) 解法不符合要求)

(1.sort;  2.map,index; 3.for() if(!containsV)put(index++)  4.if(<3)get(index-1)  get(index-3);) 

public class Solution {
    public int thirdMax(int[] nums) {
        Arrays.sort(nums);
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        int index = 0;
        for (int num : nums) {
            if (!map.containsValue(num)) {
                map.put(index++,num);
            }
        }
        if (index < 3) {
            return map.get(index - 1);
        } 
        return map.get(index - 3);
    }
}

解法2：<TreeSet> (利用TreeSet的从小到大排序和不重复性;遍历 添值; 用大小为3的滑动窗口；大于3则remove第一个数; size>=3则返回first，<3则返回last)(注意：定义set的时候只能是TreeSet开头(原因不知?),不然用不了set.first();  set.first(),set.last()是method, 别漏了()) (PS：要先add再remove,这样可以确保add进去的数已经被排序了，并且一次for循环后的size是3)  (TreeSet的操作time是O(logn);遍历O(n);size为3,所以是O(n) (not sure))

（1.TreeSet; 2.for()add if() remove; 3.return(<?:))

public class Solution {
    public int thirdMax(int[] nums) {
        TreeSet<Integer> set = new TreeSet<Integer>();
        for (int num : nums) {
            set.add(num);
            if (set.size() > 3) {
                set.remove(set.first());
            }
        }
        return (set.size() < 3 ? set.last() : set.first());
    }
}

解法3: first,second,third 三个指针;

448. Find All Numbers Disappeared in an Array: https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/

 长度为n的数组[1,n]中缺失的数：O(n),O(1)

解法：(正负标记法；第一趟,将每个nums[i]所对应的位置(nums[nums[i]-1])的数取负数,如果有重复则跳过; 第二趟, 遍历,正数的位置即为缺失的数.用到方法Math.abs()--取绝对值)

public class Solution {
    public List<Integer> findDisappearedNumbers(int[] nums) {
        List<Integer> rst = new ArrayList<Integer>();
        for (int i = 0; i < nums.length; i++) {
            int index = Math.abs(nums[i]) - 1;
            if (nums[index] > 0) {
                nums[index] = - nums[index];
            }
        }
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0) {
                rst.add(i + 1);
            }
        }
        return rst;
    }
}