[leetcode] Python(30)--二叉树的序列化与反序列化(297)、两两交换链表中的节点(24)、斐波那契数(509)、爬楼梯(70)

从零开始的力扣（第三十天）~

1.二叉树的序列化与反序列化

序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。

请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

示例:

你可以将以下二叉树：

序列化为 “[1,2,3,null,null,4,5]”
提示: 这与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。

说明: 不要使用类的成员 / 全局 / 静态变量来存储状态，你的序列化和反序列化算法应该是无状态的。
—————————————————————————————————————————

这里没有必要管什么逗号与中括号，只需要考虑字符串即可

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Codec:

    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        ans = ""
        queue = [root]
        while queue:
            Node = queue.pop(0)
            if Node:
                ans += str(Node.val)
                queue.append(Node.left)
                queue.append(Node.right)
            else:
                ans += 'null'
            ans += ' '
        return ans

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        arr = data.split()
        if arr[0] == "null":
            return None
        queue = []
        root = TreeNode(int(arr[0]))
        queue.append(root)
        i = 1
        while queue:
            cur = queue.pop(0)
            if cur == None:
                continue
            cur.left = TreeNode(int(arr[i])) if arr[i] != "null" else None
            cur.right = TreeNode(int(arr[i + 1])) if arr[i + 1] != "null" else None
            i += 2
            queue.append(cur.left)
            queue.append(cur.right)
        return root

# Your Codec object will be instantiated and called as such:
# codec = Codec()
# codec.deserialize(codec.serialize(root))

2.两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例:
给定 1->2->3->4, 你应该返回 2->1->4->3.
—————————————————————————————————————————

最重要的是保存头节点，想了很久，递归方法感觉必须要重写另一个函数才能做到

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def swap(self, first, head):
        if head is None or head.next is None:
            return
        cur = head.next
        head.next = cur.next
        cur.next = head
        first.next = cur
        self.swap(head, head.next)
        
    def swapPairs(self, head: ListNode) -> ListNode:
        first = ListNode(0)
        first.next = head
        self.swap(first, head)
        return first.next

3.斐波那契数

斐波那契数，通常用 F(n) 表示，形成的序列称为斐波那契数列。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
给定 N，计算 F(N)。

示例 1：
输入：2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1.

示例 2：
输入：3
输出：2
解释：F(3) = F(2) + F(1) = 1 + 1 = 2.

示例 3：
输入：4
输出：3
解释：F(4) = F(3) + F(2) = 2 + 1 = 3.

提示：
0 ≤ N ≤ 30
—————————————————————————————————————————

直接递归，但是会很慢

class Solution(object):
    def fib(self, N: int) -> int:
        if N == 0:
            return 0
        if N == 1:
            return 1
        return self.fib(N - 1) + self.fib(N - 2)

4.爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。

1. 1 阶 + 1 阶
2. 2 阶
   示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。

1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

—————————————————————————————————————————

直接递归会超出时间限制，动态规划完成

class Solution:
    def climbStairs(self, n: int) -> int:
        list = [0, 1, 2]
        for i in range(3, n + 1):
            list += [list[i - 1] + list[i - 2]]
        return list[n]

以上就是今日经验！