leetCode之分治法/二分法

首页目录 点击查看

第一题

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

示例

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

解题思路

  • 这道题,要求是要达到O(log n)级别,所以,只能采用二分法来处理,二分法也就是把原有数组一分为二,如果有一侧满足,就抛弃另一侧,知道中间得数等于target.

我的答案

var search = function (nums, target) {
    let left = 0;
    let right = nums.length - 1;
    while (left <= right) {
        let mid = Math.floor((left + right) / 2)
        if (nums[mid] === target) {
            return mid
        }
        if (nums[left] <= nums[mid]) {
            if (nums[left] <= target && target <= nums[mid]) {
                right = mid - 1
            } else {
                left = mid + 1
            }
        }
        if (nums[mid] <= nums[right]) {
            if (nums[mid] <= target && target <= nums[right]) {
                left = mid + 1
            } else {
                right = mid - 1
            }
        }
    }
    return -1
};
  • 时间复杂度:O(log n)


    image.png
  • 下面这个答案是不符合条件的,o(n)级别,也贴出来,性能几乎差不多
        var search = function (nums, target) {
            for (let i = 0; i <= nums.length - 1; i++) {
                if (nums[i] === target) {
                    return i
                }
            }
            return -1
        };
  • 时间复杂度:O(n)


    image.png

第二题

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

示例

输入: nums = [2,5,6,0,0,1,2], target = 0
输出: true

输入: nums = [2,5,6,0,0,1,2], target = 3
输出: false

解题思路

  • 这道题和上一道题的思路几乎一致,只是要注意,中间会有重复的,所以需要对重复项做处理,我这里有两种方法,一种是new set去重,但是复杂度明显就增加了,还有另外一个是对重复项跳过。

我的答案

  • new Set去重,会增加时间复杂度,不符合
        var search = function (nums, target) {
            nums = Array.from(new Set(nums))
            let left = 0;
            let right = nums.length - 1;
            while (left <= right) {
                let mid = Math.floor((left + right) / 2)
                if (nums[mid] === target) {
                    return true
                }
                if (nums[left] <= nums[mid]) {
                    if (nums[left] <= target && target <= nums[mid]) {
                        right = mid - 1
                    } else {
                        left = mid + 1
                    }
                }
                if (nums[mid] <= nums[right]) {
                    if (nums[mid] <= target && target <= nums[right]) {
                        left = mid + 1
                    } else {
                        right = mid - 1
                    }
                }
            }
            return false
        };

性能确实一般般


image.png
var search = function (nums, target) {
    let left = 0;
    let right = nums.length - 1;
    while (left <= right) {
        let mid = Math.floor((left + right) / 2)
        if (nums[mid] === target) {
            return true
        }
        if (nums[left] == nums[mid]) {
            left++
            continue
        }
        if (nums[left] <= nums[mid]) {
            if (nums[left] <= target && target <= nums[mid]) {
                right = mid - 1
            } else {
                left = mid + 1
            }
        }
        if (nums[mid] <= nums[right]) {
            if (nums[mid] <= target && target <= nums[right]) {
                left = mid + 1
            } else {
                right = mid - 1
            }
        }
    }
    return false
};
  • 时间复杂度:O(N)


    image.png

    没有增加时间复杂度,同时速度提升非常明显

第三题

  • 难度:中等
  • 题目:153. 寻找旋转排序数组中的最小值
    假设按照升序排序的数组在预先未知的某个点上进行了旋转。
    ( 例如,数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
    请找出其中最小的元素。
    你可以假设数组中不存在重复元素。

示例

输入: [3,4,5,1,2]
输出: 1

输入: [4,5,6,7,0,1,2]
输出: 0

解题思路

  • 用二分法查找,需要始终将目标值(这里是最小值)套住,并不断收缩左边界或右边界。
    左、中、右三个位置的值相比较,有以下几种情况:
  1. 左值 < 中值, 中值 < 右值 :没有旋转,最小值在最左边,可以收缩右边界
          右
     中
 左
  1. 左值 > 中值, 中值 < 右值 :有旋转,最小值在左半边,可以收缩右边界
 左       
          右
     中
  1. 左值 < 中值, 中值 > 右值 :有旋转,最小值在右半边,可以收缩左边界
     中  
 左 
         右

分析前面三种可能的情况,会发现情况1、2是一类,情况3是另一类。
如果中值 < 右值,则最小值在左半边,可以收缩右边界。
如果中值 > 右值,则最小值在右半边,可以收缩左边界。

我的答案

var findMin = function (nums) {
    let left = 0;
    let right = nums.length - 1;
    while (left < right) {
        let mid = Math.floor((left + right) / 2);
        if (nums[mid] > nums[right]) {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return nums[left]
};
image.png

第四题

  • 难度:中等
  • 题目:34. 在排序数组中查找元素的第一个和最后一个位置
    给定一个按照升序排列的整数数组 nums,和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
    你的算法时间复杂度必须是 O(log n) 级别。
    如果数组中不存在目标值,返回 [-1, -1]。

示例

输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]

输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]

解题思路

  • 这道题和33题类似,只是这里需要注意的是,如何找出最小角标的相同的数字,和最大角标的相同的数字,就需要在mid===target时多做一层判断。

我的答案

var searchRange = function (nums, target) {
    if (!nums.length) { return [-1, -1] }
    let start = 0;
    let end = 0
    let left = 0;
    let right = nums.length - 1;
    while (left <= right) {
        let mid = Math.floor((left + right) / 2);
        if (nums[mid] === target) {
            start = mid;
            end = mid;
            while (start > left && nums[start] === nums[start - 1]) start--;
            while (end < right && nums[end] === nums[end + 1]) end++;
            return [start, end]
        } else if (nums[mid] > target) {
            right = mid - 1
        } else if (nums[mid] < target) {
            left = mid + 1
        }
    }
    return [-1, -1]
};
  • 时间复杂度:O(logN)


    image.png

第五题

  • 难度:中等
  • 题目:74. 搜索二维矩阵
    编写一个高效的算法来判断 m x n 矩阵中,是否存在一个目标值。该矩阵具有如下特性:
  • 每行中的整数从左到右按升序排列。
  • 每行的第一个整数大于前一行的最后一个整数。

示例

输入:
matrix = [
  [1,   3,  5,  7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]
target = 3
输出: true

输入:
matrix = [
  [1,   3,  5,  7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]
target = 13
输出: false

解题思路

  • 这道题我的想法是使用双重二分法,第一层找出target所在的数组,第二层找出target所在的位置。

我的答案

var searchMatrix = function (matrix, target) {
    let left = 0;
    let right = matrix.length - 1;
    while (left <= right) {
        let mid = Math.floor((left + right) / 2)
        let len = matrix[mid].length
        if (matrix[mid][0] <= target && target <= matrix[mid][len - 1]) {
            let start = 0;
            let end = len - 1;
            while (start <= end) {
                let iMid = Math.floor((start + end) / 2);
                if (matrix[mid][iMid] === target) {
                    return true
                } else if (target < matrix[mid][iMid]) {
                    end = iMid - 1
                } else {
                    start = iMid + 1
                }
            }
            return false
        } else if (target > matrix[mid][len - 1]) {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return false
};
  • 时间复杂度:O(logN)


    image.png

你可能感兴趣的:(leetCode之分治法/二分法)