一，二叉搜索树迭代器

1，程序简介

实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器：

BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。
boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false 。
int next()将指针向右移动，然后返回指针处的数字。
注意，指针初始化为一个不存在于 BST 中的数字，所以对 next() 的首次调用将返回 BST 中的最小元素。
你可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 的中序遍历中至少存在一个下一个数字。

示例：

在这里插入图片描述

输入：
[“BSTIterator”, “next”, “next”, “hasNext”, “next”, “hasNext”, “next”, “hasNext”, “next”, “hasNext”]
[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
输出：[null, 3, 7, true, 9, true, 15, true, 20, false]
解释：
BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
bSTIterator.next(); // 返回 3
bSTIterator.next(); // 返回 7
bSTIterator.hasNext(); // 返回 True
bSTIterator.next(); // 返回 9
bSTIterator.hasNext(); // 返回 True
bSTIterator.next(); // 返回 15
bSTIterator.hasNext(); // 返回 True
bSTIterator.next(); // 返回 20
bSTIterator.hasNext(); // 返回 False

提示：

树中节点的数目在范围 [1, 105] 内
$0 <= Node.val <= 10^6$
最多调用 105 次 hasNext 和 next 操作

进阶：

你可以设计一个满足下述条件的解决方案吗？next() 和 hasNext() 操作均摊时间复杂度为 O(1) ，并使用 O(h) 内存。其中 h 是树的高度。

2，程序代码

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class BSTIterator:
    def __init__(self, root: TreeNode):
        self.index = -1
        self.node_list = []
        self._iterator(root)
    def _iterator(self, root):
        if not root:
            return
        self._iterator(root.left)
        self.node_list.append(root.val)
        self._iterator(root.right)
    def next(self) -> int:
        """
        @return the next smallest number
        """
        self.index += 1
        return self.node_list[self.index]
    def hasNext(self) -> bool:
        """
        @return whether we have a next smallest number
        """
        return self.index + 1 < len(self.node_list)
# Your BSTIterator object will be instantiated and called as such:
# obj = BSTIterator(root)
# param_1 = obj.next()
# param_2 = obj.hasNext()

3，运行结果

二，数字 1 的个数

1，程序简介

给定一个整数 n，计算所有小于等于 n 的非负整数中数字 1 出现的个数。

示例 1：

输入：n = 13
输出：6

示例 2：

输入：n = 0
输出：0

提示：

0 <= n <= 109

2，程序代码

class Solution:
    def countDigitOne(self, n: int) -> int:
        res, i = 0, 1
        while i <= n:
            res += n // (i * 10) * i
            x = (n // i) % 10
            res += i if x > 1 else (n % i + 1) * x
            i *= 10
        return res

3，运行结果

三，反转链表

1，程序简介

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

在这里插入图片描述

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

在这里插入图片描述

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

示例 3：

输入：head = []
输出：[]

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000
进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

2，程序代码

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
class Solution:
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        current = head
        nextNode = None
        h = head
        while current is not None and current.next is not None:
            nextNode = current.next
            if nextNode.next is not None:
                tmpNode = current.next
                current.next = nextNode.next
                tmpNode.next = h
            else:
                current.next = None
                nextNode.next = h
            h = nextNode
        return h