6-29刷题

Remove Element

    int removeElement(vector<int> &A, int elem) {
        int i = 0;
        int pointer = A.size() - 1;
        while (i <= pointer) {
            if (A[i] == elem) {
                A[i] = A[pointer];
                --pointer;
            } else {
                ++i;
            }
        }
        return pointer + 1;
    }

 

Subarray Sum

    public ArrayList<Integer> subarraySum(int[] nums) {
        ArrayList<Integer> ret = new ArrayList<Integer>();
        for (int i = 0; i < nums.length; ++i) {
            int sum = 0;
            for (int j = i; j < nums.length; ++j) {
                sum += nums[j];
                if (sum == 0) {
                    ret.add(i);
                    ret.add(j);
                    return ret;
                }
            }
        }
        return ret;
    }

 

Remove Duplicates from Sorted Array

    public int removeDuplicates(int[] nums) {
        int len = 0;
        int i = 0;
        while (i < nums.length) {
            int p = i + 1;
            while (p < nums.length && nums[p] == nums[i]) ++p;
            nums[len] = nums[i];
            ++len;
            i = p;
        }
        return len;
    }

 

 int removeDuplicates(vector<int> &nums) {
        if (nums.size() == 0) return 0;
        int len = 0;
        for (int i = 0; i < nums.size(); ++i) {
            if (nums[i] != nums[len]) {
                nums[++len] = nums[i];
            }
        }
        return len + 1;
    }

 

Merge Sorted Array

   public void mergeSortedArray(int[] A, int m, int[] B, int n) {
        for (int i = 0; i < n; ++i) {
            A[m + i] = B[i];
            int p = m + i;
            while (p > 0 && A[p - 1] > B[i]) {
                A[p] = A[p - 1];
                --p;
            }
            A[p] = B[i];
        }
    }

public void mergeSortedArray(int[] A, int m, int[] B, int n) {
        int i = m - 1, j = n - 1, index = m + n - 1;
        while (i >= 0 && j >= 0) {
            A[index--] = A[i] > B[j] ? A[i--] : B[j--];
        }
        while (i >= 0) {
            A[index--] = A[i--];
        }
        while (j >= 0) {
            A[index--] = B[j--];
        }
    }

 

Product of Array Exclude Itself

    public ArrayList<Long> productExcludeItself(ArrayList<Integer> A) {
        ArrayList<Long> ret = new ArrayList<Long>();
        if (A == null || A.size() == 0) return ret;
        ret.add(1L);
        for (int i = 1; i < A.size(); ++i) {
            long bi = (long) ret.get(i - 1);
            int ai = (int) A.get(i - 1);
            ret.add(bi * ai);
        }
        Long b0 = ret.get(0);
        for (int i = A.size() - 2; i >= 0; --i) {
            int ai = (int) A.get(i + 1);
            b0 *= ai;
            Long bi = ret.get(i);
            bi *= b0;
            ret.set(i, bi);
        }
        ret.set(0, b0);
        return ret;
    }