leetcode 之 旋转数组问题

数组(不重复)旋转问题之查找指定元素(leetcode 33)

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。

#inlcude <assert>
class Solution {
public:
    int search(vector<int>& nums, int target) {
        if (nums.size() == 0) 
            return -1;
        int l = 0;
        int r = nums.size()-1;
        while(l <= r){
            int mid = l + (r -l )/2;
            if (nums[l] == target) return l;
            else if (nums[r] == target) return r;
            else if (nums[mid] == target) return mid;
            else {
                if (nums[mid] > target){
                    if (nums[mid] > nums[0]){
                        // mid在左边
                        if (target > nums[0]){
                            // mid在左边，target也在左边
                            r = mid - 1;
                        }else{
                            // mid在左边，target在右边
                            l = mid + 1;
                        }
                    }else{
                        // mid在右边， target也在右边
                        r = mid - 1;
                    }
                }else {
                    if (nums[mid] > nums[0]){
                        // mid在左边，target也在左边
                        l = mid + 1;
                    }else{
                        // mid在右边
                        if (target > nums[0]){
                            // mid在右边，target也在左边
                            r = mid - 1;
                        }else{
                            //mid在右边，target在右边
                            l = mid + 1;
                        }
                    }
                }
            }
        }
        return -1;
    }
};

数组(重复)旋转问题之查找指定元素是否存在(leetcode 81)

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。
编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        if (nums.size() == 0) return false;
        
        int l = 0;
        int r = nums.size()-1;
        while(l<=r){
            int mid = l + ( r-l )/2;
            if (nums[l] == target || nums[r] == target || nums[mid] == target) return true;
            if (nums[mid] > nums[l]){
                if (nums[mid] > target){
                    // mid在左边
                    if (target> nums[l]){
                        // mid在左边，target在左边
                        r = mid - 1;
                    }else{
                        // mid在左边，target在右边
                        l = mid + 1; 
                    }
                }else{
                    l = mid + 1;
                }
            }else if (nums[mid] < nums[l]){
                if (nums[mid] > target){
                    r = mid - 1; 
                }else{
                    if (target > nums[l]){
                        r = mid -1;
                    }else{
                        l = mid + 1;
                    }
                }
            }else {
                l++;
            }
        }
        return false;
    }
};

注：再可重复数组中查找元素的方法均可适用于非重复数组的元素查找问题上，所以该题的解法同样适合解决第一个问题

数组(不重复)旋转问题之查找最小值(leetcode 153)

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

class Solution {
public:
    // You may assume no duplicate exists in the array.数组元素不重复
    int findMin(vector<int>& nums) {
        // 判断数组长度是否为1，则直接返回最小值
        if (nums.size() == 1) return nums[0];
        // 判断数组是否进行旋转，若未进行旋转则第一个值就是最小值
        if (nums[0] < nums[nums.size()-1]) return nums[0];
        
        int left = 0 ;
        int right = nums.size() -1;
        // 在数组中找最小值的判定条件是： l > m; m < r
        while( left <= right){
            int mid = left + (right-left)/2;
            // 判断中间值是不是最小值
            if (mid>=1 && mid+1 < nums.size() && nums[mid] < nums[mid-1] && nums[mid] < nums[mid+1]){
                return nums[mid];
            }else if (left>=1 && left+1< nums.size() && nums[left] < nums[left-1] && nums[left] < nums[left+1]){
                // 判断left是不是最小值
                return nums[left];
            }else if (right >= 1 && right+1 < nums.size() && nums[right] < nums[right-1] && nums[right] < nums[right+1]){
                // 判断right 是不是最小值
                return nums[right];
            }else {
                // left、right、mid都不是最小值，
                if (nums[left] > nums[mid]){
                    left = left + 1;
                }else {
                    right = right - 1 ;
                }
            }
        }
        // (0, nums.size()-1)之间没有找到最小值, 那么最小元素肯定存在于两端
        return nums[0]>nums[nums.size()-1]? nums[nums.size()-1]: nums[0];
    }
};

数组(重复)旋转问题之查找最小值(leetcode 154)

在该题目中，要求是查找最小元素切数组有序，在一般情况下是使用二分查找法可以快速的查找到元素，但是代码看起来比较繁琐，在此我没有使用二分查找法。

int findMin(vector<int>& nums) {
    if (nums.size() == 1 || nums[0] < nums[nums.size()-1]) return nums[0];
    // if (nums.size() == 2) return nums[0]>nums[1]?nums[1]:nums[0];
    // if (nums[0] < nums[nums.size()-1]) return nums[0];
    int left = 0;
    int right = nums.size()-1;
    cout << "test" << right << endl;
    int i = left+1;
    for ( ;i<right && nums[i] >=nums[i-1];i++){
        cout << nums[i] << endl;
    }
    return nums[i];
}

情况一：先判断数组是否只有一个元素，如果是这样的话直接返回第一个元素即可，这就是最小值。
情况二：数组元素至少有两个及以上。首先找到最小值的条件是array[i]>=array[i-1] ，我采用前一个元素和后一个元素进行比较，如果array[i] >= array[i-1]则i++, 直到for循环停止。如果在for循环中找到最小值时，那么就直接返回最小值。如果找不到，那么array[array.size()-1]就是最小值，返回即可。

时间复杂度分析：
最坏情况：Ｏ(n)
最好情况：Ｏ(1)
平均时间复杂度：O(n/2)

随着数据的增大，这样的时间复杂度要比二分查找效率低。所以建议采用二分查找算法实现吧。

二分法实现

int left = 0;
        int right = nums.size()-1;
        while (left < right){
            int mid = left + (right - left)/2;
            if (nums[mid] > nums[right]){
                // mid大于right值，将mid赋值给left缩小查找范围[mid+1, right]
                left = mid + 1;
            }else if (nums[mid] < nums[right]){
                // mid小于right,　将mid赋值给right缩小查找范围[left, mid]
                right = mid;
            }else {
                // mid == right, right--，　因为mid是与right比较的，所以应该right--,而不应该left++;
                right = right - 1;
            }
        }
        return nums[left];

---

查找元素之返回下标
可重复数组查找元素是否存在
最小值查找