文章目录
一，二叉树的序列化与反序列化
1，程序简介
序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。
请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。
提示: 输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式(/faq/#binary-tree)。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。
示例 1：
- 输入：root = [1,2,3,null,null,4,5]
- 输出：[1,2,3,null,null,4,5]
示例 2：
- 输入：root = []
- 输出：[]
示例 3：
- 输入：root = [1]
- 输出：[1]
示例 4：
- 输入：root = [1,2]
- 输出：[1,2]
提示：
- 树 中 结 点 数 在 范 围 [ 0 , 1 0 4 ] 内 树中结点数在范围 [0, 10^4] 内 树中结点数在范围[0,104]内
- -1000 <= Node.val <= 1000
2，程序代码
# -*- coding: utf-8 -*-
"""
Created on Wed Feb 16 18:48:30 2022
Function: 二叉树的序列化与反序列化
@author: 小梁aixj
"""
class TreeNode:
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
"""
if root == None:
return "null,"
left_serialize = self.serialize(root.left)
right_serialize = self.serialize(root.right)
return str(root.val) + "," + left_serialize + right_serialize
def deserialize(self, data):
"""Decodes your encoded data to tree.
:type data: str
:rtype: TreeNode
"""
def dfs(queue):
val = queue.popleft()
if val == "null":
return None
node = TreeNode(val)
node.left = dfs(queue)
node.right = dfs(queue)
return node
from collections import deque
queue = deque(data.split(","))
return dfs(queue)
# Your Codec object will be instantiated and called as such:
# codec = Codec()
# codec.deserialize(codec.serialize(root))
二，填充每个节点的下一个右侧节点指针 II
1，程序简介
给定一个二叉树
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
进阶：
- 你只能使用常量级额外空间。
- 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
示例：
- 输入：root = [1,2,3,4,5,null,7]
- 输出：[1,#,2,3,#,4,5,7,#]
- 解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），’#’ 表示每层的末尾。
提示：
- 树中的节点数小于 6000
- -100 <= node.val <= 100
2，程序代码
# -*- coding: utf-8 -*-
"""
Created on Wed Feb 16 18:54:38 2022
Function: 填充每个节点的下一个右侧节点指针 II
@author: 小梁aixj
"""
class Node(object):
def __init__(self, val, left, right, next):
self.val = val
self.left = left
self.right = right
self.next = next
class Solution:
def connect(self, root: "Node") -> "Node":
if root == None:
return None
firstNode = root
while firstNode:
while firstNode and firstNode.left == None and firstNode.right == None:
firstNode = firstNode.next
if firstNode == None:
break
cur = firstNode
pre = None
while cur:
if cur.left:
if pre:
pre.next = cur.left
pre = cur.left
if cur.right:
if pre:
pre.next = cur.right
pre = cur.right
cur = cur.next
firstNode = firstNode.left if firstNode.left else firstNode.right
return root
三，存在重复元素 II
1，程序简介
给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的 绝对值 至多为 k。
示例 1:
- 输入: nums = [1,2,3,1], k = 3
- 输出: true
示例 2:
- 输入: nums = [1,0,1,1], k = 1
- 输出: true
示例 3:
- 输入: nums = [1,2,3,1,2,3], k = 2
- 输出: false
2，程序代码
# -*- coding: utf-8 -*-
"""
Created on Wed Feb 16 18:54:58 2022
Function: 存在重复元素 II
@author: 小梁aixj
"""
class Solution:
def containsNearbyDuplicate(self, nums, k):
"""
:type nums: List[int]
:type k: int
:rtype: bool
"""
if len(list(set(nums))) == len(nums):
return False
left = 0
right = left + k
if k >= len(nums):
return len(list(set(nums))) < len(nums)
while right < len(nums):
while left < right:
if nums[left] == nums[right]:
return True
else:
right -= 1
left += 1
right = left + k
if len(list(set(nums[left:]))) < len(nums[left:]):
return True
return False
