Python|每日一练|单选记录：环形链表|最小栈|计算右侧小于当前元素的个数-CSDN博客

1、环形链表

给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。否则，返回 false 。

进阶：

你能用 O(1)（即，常量）内存解决此问题吗？

示例 1：

输入：head = [3,2,0,-4], pos = 1

输出：true

解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0

输出：true

解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1

输出：false

解释：链表中没有环。

提示：

链表中节点的数目范围是 [0, 104]
-105 <= Node.val <= 105
pos 为 -1 或者链表中的一个有效索引。

示例代码：

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        if not (head and head.next):
            return False
        slow = head
        fast = head.next
        while fast.next and fast.next.next:
            if slow == fast:
                return True
            slow = slow.next
            fast = fast.next.next
        return False

2、最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。

示例:

输入：

["MinStack","push","push","push","getMin","pop","top","getMin"]

[[],[-2],[0],[-3],[],[],[],[]]

输出：

[null,null,null,null,-3,null,0,-2]

解释：

MinStack minStack = new MinStack();

minStack.push(-2);

minStack.push(0);

minStack.push(-3);

minStack.getMin(); --> 返回 -3.

minStack.pop();

minStack.top(); --> 返回 0.

minStack.getMin(); --> 返回 -2.

提示：

pop、top 和 getMin 操作总是在非空栈上调用。

示例代码：

class MinStack:
    def __init__(self):
        self.data = [(None, float("inf"))]
    def push(self, x: "int") -> "None":
        self.data.append((x, min(x, self.data[-1][1])))
    def pop(self) -> "None":
        if len(self.data) > 1:
            self.data.pop()
    def top(self) -> "int":
        return self.data[-1][0]
    def getMin(self) -> "int":
        return self.data[-1][1]
# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(x)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

3、计算右侧小于当前元素的个数

给你`一个整数数组 nums ，按要求返回一个新数组 counts 。数组 counts 有该性质： counts[i] 的值是 nums[i] 右侧小于 nums[i] 的元素的数量。

示例 1：

输入：nums = [5,2,6,1]

输出：[2,1,1,0]

解释：

5 的右侧有 2 个更小的元素 (2 和 1)

2 的右侧仅有 1 个更小的元素 (1)

6 的右侧有 1 个更小的元素 (1)

1 的右侧有 0 个更小的元素

示例 2：

输入：nums = [-1]

输出：[0]

示例 3：

输入：nums = [-1,-1]

输出：[0,0]

提示：

1 <= nums.length <= 105
-104 <= nums[i] <= 104

示例代码：

class Solution:
    def countSmaller(self, nums: List[int]) -> List[int]:
        n = len(nums)
        if n == 0:
            return []
        numsarr = [[nums[i], i] for i in range(n)]
        res = [0 for _ in range(n)]
        def merge(left, right):
            if left == right:
                pass
            else:
                mid = left + (right - left) // 2
                merge(left, mid)
                merge(mid + 1, right)
                temp = []
                i = left
                j = mid + 1
                while i <= mid and j <= right:
                    if numsarr[i][0] <= numsarr[j][0]:
                        temp.append(numsarr[j])
                        j += 1
                    else:
                        temp.append(numsarr[i])
                        res[numsarr[i][1]] += right - j + 1
                        i += 1
                while i <= mid:
                    temp.append(numsarr[i])
                    i += 1
                while j <= right:
                    temp.append(numsarr[j])
                    j += 1
                numsarr[left : right + 1] = temp[:]
        merge(0, n - 1)
        return res