LeetCode--Sort Array By Parity && N-Repeated Element in Size 2N Array (Easy)

905. Sort Array By Parity (Easy)#

Given an array A of non-negative integers, return an array consisting of all the even elements of A, followed by all the odd elements of A.

You may return any answer array that satisfies this condition.

Example 1:

Input: [3,1,2,4]
Output: [2,4,3,1]
The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.

Note:

1 <= A.length <= 5000
0 <= A[i] <= 5000

solution##

我的解法

class Solution {
    public int[] sortArrayByParity(int[] A) {
        int i = 0, j = A.length - 1; int temp;
        while (i < j)
        {
            if (A[i] % 2 != 0)
            {
                while (A[j] % 2 != 0 & i < j)
                    j--;
                if (i < j)
                {
                    temp = A[i];
                    A[i] = A[j];
                    A[j] = temp;
                    j--;
                }
            }
            i++;
        }
        return A;
    }
}

大佬的解法

    public int[] sortArrayByParity(int[] A) {
        for (int i = 0, j = 0; j < A.length; j++)
            if (A[j] % 2 == 0) {
                int tmp = A[i];
                A[i++] = A[j];
                A[j] = tmp;;
            }
        return A;
    }

reference

https://leetcode.com/problems/sort-array-by-parity/discuss/170734/C%2B%2BJava-In-Place-Swap

总结##

此题主要考察数组相关的知识点。我的思路借鉴了快速排序的思想。首先设置两个计数器i与j分别记录数组的开头下标和结尾下标，然后用一个while循环从数组左端开始遍历数组，如果A[i]为奇数，则用一个while循环从数组右端开始遍历数组，直到A[j]为偶数（注意i<j）则跳出循环。假如此时j处的元素为偶数，如果i<j，就交换A[i]和A[j]，并将j++，否则什么都不做。最后，当外层循环结束后，将A返回。

大佬的解法是将数组中的偶数与前面的奇数交换，即当遍历数组时，遇到奇数就跳过，遇到偶数就与前面的奇数相交换。

Notes:

1.此类数组问题最好只用题目给定的数组解决问题，如无必要，不要用额外的数组来存储中间结果。比如此题，如果新建一个int数组来存储结果，虽然也可以做出来，但是就失去了题目想要考察的技巧了。

961. N-Repeated Element in Size 2N Array (Easy)

In a array A of size 2N, there are N+1 unique elements, and exactly one of these elements is repeated N times.

Return the element repeated N times.

Example 1:

Input: [1,2,3,3]
Output: 3

Example 2:

Input: [2,1,2,5,3,2]
Output: 2

Example 3:

Input: [5,1,5,2,5,3,5,4]
Output: 5

Note:

4 <= A.length <= 10000
0 <= A[i] < 10000
A.length is even

solution##

我的解法

class Solution {
    public int repeatedNTimes(int[] A) {
        Set<Integer> s = new HashSet<Integer>();
        for (int i = 0; i < A.length / 2 + 2; i++)
        {
            if (!s.add(new Integer(A[i])))
                return A[i];
        }
        return -1;
    }
}

大佬的解法，虽然有缺陷，但思想值得学习

//法一，利用数组数字充当数组下标，有意思。
//O(N) time, O(N) space
 public int repeatedNTimes(int[] A) {
        int[] count = new int[10000];
        for (int a : A)
            if (count[a]++ == 1)
                return a;
        return -1;
    }

//法二，将数组中的某一个数与其前面的两个数作比较，看是否相等。是否可以增加比较的数字个数，或许最好前后比较。
//O(N) time，O(1) space
    public int repeatedNTimes(int[] A) {
        for (int i = 2; i < A.length; ++i)
            if (A[i] == A[i - 1] || A[i] == A[i - 2])
                return A[i];
        return A[0];
    }

//法三，随机挑选数组中的两个数字作比较
//O(4) time, O(1) space
public int repeatedNTimes(int[] A) {
        int i = 0, j = 0, n = A.length;
        while (i == j || A[i] != A[j]) {
            i = (int)(Math.random() * n);
            j = (int)(Math.random() * n);
        }
        return A[i];
    }

reference：

https://leetcode.com/problems/n-repeated-element-in-size-2n-array/discuss/208563/JavaC%2B%2BPython-O(1)-Solution

总结##

此题思路很多。我的思路是构建一个HashSet，然后遍历数组，将数组里面的int值转为Integer后加到HashSet集合里面，如果值已经加到HashSet里面了，则就会返回false，此时直接返回当前的int数值。若遍历完毕，还没找到，则返回-1。

Notes：

1.java集合类只能存放引用类型，所以此题得将int转化为Integer后再放入集合。比如，Integer a = new Integer(A[i]);

2.数组里面的值（int）也可以当新的数组的下标，这种做法可以用来对数字计数；