leetCode-Can Place Flowers

Description:
Suppose you have a long flowerbed in which some of the plots are planted and some are not. However, flowers cannot be planted in adjacent plots - they would compete for water and both would die.

Given a flowerbed (represented as an array containing 0 and 1, where 0 means empty and 1 means not empty), and a number n, return if n new flowers can be planted in it without violating the no-adjacent-flowers rule.

Example 1:

Input: flowerbed = [1,0,0,0,1], n = 1
Output: True

Example 2:

Input: flowerbed = [1,0,0,0,1], n = 2
Output: False

Note:

The input array won't violate no-adjacent-flowers rule.
The input array size is in the range of [1, 20000].
n is a non-negative integer which won't exceed the input array size.

My Solution:

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        int count = 0;
        int len = flowerbed.length;
        if(len == 1){
            return flowerbed[0] == 0 || n == 0;
        }
        for(int i = 0;i < len;i++){
            if(flowerbed[i] == 0){
                 if(i == 0){
                     if(flowerbed[i + 1] == 0){
                         flowerbed[i] = 1;
                         count++;
                         i++;
                     }
                 }else if(i == len - 1){
                     if(flowerbed[i - 1] == 0){
                         flowerbed[i] = 1;
                         count++;
                     }
                 }else{
                     if(flowerbed[i - 1] == 0 && flowerbed[i + 1] == 0){
                         flowerbed[i] = 1;
                         count++;
                     }
                 }
                if(count >= n){
                    return true;
                }
            }
        }
        return false;
    }
}

Better Solution:

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        int[] a = flowerbed;
        if (a == null || a.length == 0) {
            return true;
        }
        int rst = 0;
        for (int i = 0; i < a.length; ++i) {
            if (a[i] == 0) {
                int prev = i == 0 ? 0 : a[i - 1];
                int next = i == a.length - 1 ? 0 : a[i + 1];
                if (prev == 0 && next == 0) {
                    rst++;
                    a[i] = 1;
                }
            }
        }
        return rst >= n;
    }
}

Best Solution:

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        //int place = 0, noplace = 0;
        int tmp = 0;
        for(int i = 0; i < flowerbed.length; i++)
        {
            if(flowerbed[i] == 1)
            {
                i += 1;
            }
            else if(i < (flowerbed.length -1) && flowerbed[i+1] == 1)
            {
                i += 2;
            }
            else
            {
                tmp ++;
                i++;
            }
        }
        if(n <= tmp)
            return true;
        return false;

    }
}