Leetcode Search in rotated sorted array I, II

Suppose a sorted array is rotated at some pivot unknown to you beforehand. (i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).
You are given a target value to search. If found in the array return its index, otherwise return -1.
You may assume no duplicate exists in the array.

[code]

public class Solution {
    public int search(int[] A, int target) {
        if(A==null || A.length==0)return -1;
        return helper(A, 0, A.length-1, target);
    }

    int helper( int[]a, int start, int end, int target)
    {
        if(start>end)return -1;
        int mid=(start+end)/2, middle=a[mid];
        if(middle==target)return mid;

        if(middle<a[start])
        {
            if(middle<target)
            {
                int left=helper(a,start,mid-1,target);
                if(left==-1)return helper(a,mid+1,end,target);
                else return left;
            }
            else return helper(a,start,mid-1,target);
        }
        else
        {
            if(middle<target)return helper(a, mid+1,end,target);
            else
            {
                int left=helper(a,start,mid-1,target);
                if(left==-1)return helper(a,mid+1,end,target);
                else return left;

            }
        }
    }
}

---

What if duplicates are allowed?
Would this affect the run-time complexity? How and why?
Write a function to determine if a given target is in the array.
[code]

public class Solution {
    public boolean search(int[] A, int target) {
        if(A==null || A.length==0)return false;
        return helper(A, 0, A.length-1, target);
    }

    boolean helper( int[]a, int start, int end, int target)
    {
        if(start>end)return false;
        int mid=(start+end)/2, middle=a[mid];
        if(middle==target)return true;

        if(middle<a[start])
        {
            if(middle<target)
            {
                boolean left=helper(a,start,mid-1,target);
                if(left==false)return helper(a,mid+1,end,target);
                else return left;
            }
            else return helper(a,start,mid-1,target);
        }
        else if(middle>a[start])
        {
            if(middle<target)return helper(a, mid+1,end,target);
            else
            {
                boolean left=helper(a,start,mid-1,target);
                if(left==false)return helper(a,mid+1,end,target);
                else return left;

            }
        }
        else
        {
            int i=start;
            while(i<=end && a[i]==a[start])i++;
            if(i>end)return false;
            int j=end;
            while(j>=start && a[j]==a[start])j--;
            if(j<start)return false;
            return helper(a,i,j,target);
        }
    }
}