每日一练 — 2022.02.11

---

一，寻找旋转排序数组中的最小值

1，程序简介

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：

• 若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
• 若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]

注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

示例 1：

• 输入：nums = [3,4,5,1,2]
• 输出：1
• 解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。

示例 2：

• 输入：nums = [4,5,6,7,0,1,2]
• 输出：0
• 解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。

示例 3：

• 输入：nums = [11,13,15,17]
• 输出：11
• 解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

提示：

• n == nums.length
• 1 <= n <= 5000
• -5000 <= nums[i] <= 5000
• nums 中的所有整数 互不相同
• nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转

2，程序代码

# -*- coding: utf-8 -*-
"""
Created on Thu Feb 10 19:51:08 2022
Function: 寻找旋转排序数组中的最小值
@author: 小梁aixj
"""
class Solution(object):
    def findMin(self, nums):
        flag = True
        if nums[0] < nums[-1]:
            flag = True
        else:
            flag = False
        for i in range(1, len(nums)):
            if flag:
                if nums[i] < nums[i - 1]:
                    return nums[i]
            else:
                if nums[len(nums) - i] < nums[len(nums) - 1 - i]:
                    return nums[len(nums) - i]
        return nums[0]

二，岛屿数量

1，程序简介

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1：

• 输入：grid = [
  [“1”,“1”,“1”,“1”,“0”],
  [“1”,“1”,“0”,“1”,“0”],
  [“1”,“1”,“0”,“0”,“0”],
  [“0”,“0”,“0”,“0”,“0”]
  ]
• 输出：1

示例 2：

• 输入：grid = [
  [“1”,“1”,“0”,“0”,“0”],
  [“1”,“1”,“0”,“0”,“0”],
  [“0”,“0”,“1”,“0”,“0”],
  [“0”,“0”,“0”,“1”,“1”]
  ]
• 输出：3

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 300
• grid[i][j] 的值为 ‘0’ 或 ‘1’

2，程序代码

# -*- coding: utf-8 -*-
"""
Created on Thu Feb 10 19:51:23 2022
Function: 岛屿数量
@author: 小梁aixj
"""
class Solution:
    def depthSearch(self, grid, i, j):
        if i < 0 or j < 0 or i >= len(grid) or j >= len(grid[0]):
            return
        if grid[i][j] == "0":
            return
        grid[i][j] = "0"
        self.depthSearch(grid, i - 1, j)
        self.depthSearch(grid, i + 1, j)
        self.depthSearch(grid, i, j - 1)
        self.depthSearch(grid, i, j + 1)
    def numIslands(self, grid: List[List[str]]) -> int:
        if not grid:
            return 0
        w, h = len(grid[0]), len(grid)
        cnt = 0
        for i in range(h):
            for j in range(w):
                if grid[i][j] == "1":
                    self.depthSearch(grid, i, j)
                    cnt += 1
        return cnt

三，回文链表

1，程序简介

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

示例 1：

• 输入：head = [1,2,2,1]
• 输出：true

示例 2：

• 输入：head = [1,2]
• 输出：false

提示：

• 链表中节点数目在范围[1, 105] 内
• 0 <= Node.val <= 9

进阶：

• 你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

2，程序代码

# -*- coding: utf-8 -*-
"""
Created on Thu Feb 10 19:49:53 2022
Function: 回文链表
@author: 小梁aixj
"""
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        lst = []
        node = head
        while node:
            lst.append(node.val)
            node = node.next
        start = 0
        end = len(lst) - 1
        while start < end:
            if lst[start] != lst[end]:
                return False
            start += 1
            end -= 1
        return True