Leetcode题解 0025期

羡慕、嫉妒、以及负能量爆发

0092题 反转链表 II【Reverse Linked List II】

题目：
反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。

说明： 1 ≤ m ≤ n ≤ 链表长度。

示例：

输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL

题目相对严谨

链表题目，小心NULL的情况

解题思路：
这题其实难点在于必须一趟扫描，但实际上相对好些。想起来之前说新建链表什么之类的胡话，那种东西是肯定不对的，说了要在链表上面进行操作，那就不能新建链表啊……
post代码：

class Solution:
    def reverseBetween(self, head, m, n):
        if head == None or m == n: return head
        return_head = None
        record_head = None
        tail = None
        one_node_before_tail = None
        cnt = 1
        flag = False
        while head != None:
            if cnt < m:
                if return_head == None and record_head == None:
                    return_head = record_head = head
                record_head = head
                head = head.next
            elif cnt == m:
                tail = one_node_before_tail = head
                head = head.next
                tail.next = None
                one_node_before_tail.next = None
            elif cnt <= n:
                tmp_node = head
                head = head.next
                tmp_node.next = one_node_before_tail
                one_node_before_tail = tmp_node
            else:
                flag = True
                if record_head == None:
                    return_head = record_head = one_node_before_tail
                else:
                    record_head.next = one_node_before_tail
                tail.next = head
                break

            cnt += 1

        if not flag:
            if record_head == None:
                return_head = record_head = one_node_before_tail
            else:
                record_head.next = one_node_before_tail

        return return_head

虽然我的代码可能并不是最简洁的，但是思路是正确的，而且读起来毫无压力，非常有逻辑感，而且小心翼翼。

---

0093题 复原IP地址【Restore IP Addresses】

题目：
给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。
示例：

输入: "25525511135"
输出: ["255.255.11.135", "255.255.111.35"]

题目相对严谨

需要注意：
1. IP地址的定义，及其上限
2. 注意处理0的问题，0一定有意义，不能没有否则不应该存在0
3. 如果没有解法的话，返回应该是空集
4. Robust

解题思路：
这题就是暴力搜索或者枚举点可能出现的位置，然后注意上述情况即可

class Solution:
    def restoreIpAddresses(self, s):
        n = len(s)
        res = []
        tmp = []
        for i in range(1,1+3):
            if i > n: break
            if len(s[0:i]) != len(str(int(s[0:i]))): break
            if int(s[0:i]) > 255: break
            tmp.append(s[0:i])
            for j in range(i+1,i+4):
                if j > n: break
                if len(s[i:j]) != len(str(int(s[i:j]))): break
                if int(s[i:j]) > 255: break
                tmp.append(s[i:j])
                for k in range(j+1,j+4):
                    if k >= n: break
                    if len(s[j:k]) != len(str(int(s[j:k]))): break
                    if int(s[j:k]) > 255: break
                    tmp.append(s[j:k])

                    if len(s[k:]) > 3: tmp.pop();continue
                    if len(s[k:]) != len(str(int(s[k:]))): tmp.pop();continue
                    if int(s[k:]) > 255: tmp.pop();continue

                    tmp.append(s[k:])
                    res.append(".".join(tmp))

                    tmp.pop()
                    tmp.pop()
                tmp.pop()
            tmp.pop()

        return res

模拟栈就可以了，以上

---

0094题 二叉树的中序遍历【Binary Tree Inorder Traversal】

题目：
给定一个二叉树，返回它的中序遍历。
进阶: 递归算法很简单，你可以通过迭代算法完成吗？
示例：

输入: [1,null,2,3]
   1
    \
     2
    /
   3

输出: [1,3,2]

题目相对严谨

除Robust外无需注意太多

解题思路：
周一周二周四周五一日三道题，其他时间一天四道题，先这样。
终于开始树了，2333，这题很简单，不用多说，直接完成进阶要求

class Solution:
    def inorderTraversal(self, root):
        res = []
        stack = []
        if root == None: return res
        p = root
        while True:
            while p != None:
                stack.append(p)
                p = p.left
            if len(stack) == 0: break
            p = stack.pop()
            res.append(p.val)

            p = p.right

        return res