1.删除排序链表中的重复元素
题目：
给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
示例：
输入: 1->1->2->3->3 输出: 1->2->3
代码：
# Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution: def deleteDuplicates(self, head: ListNode) -> ListNode: # 如果head为空，返回None if not head: return None # temp作为前后比较的指针，初始指向head temp = head # res作为结果链表的指针，初始指向head res = head # 如果还有下一个节点，则前后比较val while temp.next: # 如果前后不相等 if temp.val != temp.next.val: # 让res指向后面那个 res.next = temp.next # res移一个节点 res = res.next temp = temp.next # 循环结束的时候可能最后几个是相同的，扔掉最后几个相同的，只取res指向的那个节点 res.next = None return head
2.合并两个有序数组
题目：
给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。
说明:
初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。
示例：
输入: nums1 = [1,2,3,0,0,0], m = 3 nums2 = [2,5,6], n = 3 输出: [1,2,2,3,5,6]
代码：
class Solution: def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None: """ Do not return anything, modify nums1 in-place instead. """ p1=m-1 # 获取nums1的最大索引 p2=n-1 # 获取nums2的最大索引 p=m+n-1 # 获取合并后nums1的最大索引 # 两个列表都还有值 while p1>=0 and p2>=0: # 谁大，谁放后面 if nums1[p1]<nums2[p2]: nums1[p]=nums2[p2] p2-=1 else: nums1[p]=nums1[p1] p1-=1 # p向前移一格 p-=1 # 某个列表没有元素了（假设nums1没有元素了，则剩下的nums2直接拷贝到最前面）（假设nums2没有元素了p2+1=0，所以下面语句不会赋值元素） nums1[:p2+1]=nums2[:p2+1]
总结：
# 这种in-place合并问题，我们可以找到一个正确的方向来写入值，在写入的同时不影响本身还未使用的元素 # 这里我们就选择从nums1的最后（合并后总长度）开始向前按顺序存放值，这样在存放的过程中也不会影响nums1和nums2中途未使用的元素
3.相同的树
题目：
给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
示例：
输入: 1 1
/ /
2 3 2 3
[1,2,3], [1,2,3]
输出: true
输入: 1 1
/ /
2 1 1 2
[1,2,1], [1,1,2]
输出: false
代码1：
class Solution: def isSameTree(self, p: TreeNode, q: TreeNode) -> bool: """ :type p: TreeNode :type q: TreeNode :rtype: bool """ # 如果都为None，则相等 if not p and not q: return True # 如果其中有一个为None，另一个不是None，则不相等 if not q or not p: return False # p和q的val不同，不相等 if p.val != q.val: return False # p和q的左右子节点分别相同，才相同 return self.isSameTree(p.right, q.right) and self.isSameTree(p.left, q.left)
递归解法。
时间复杂度 : O(N)，其中 N 是树的结点数，因为每个结点都访问一次。
空间复杂度 : 最优情况（完全平衡二叉树）时为 O(log(N))，最坏情况下（完全不平衡二叉树）时为O(N)，用于维护递归栈。
代码2：
from collections import deque class Solution: def isSameTree(self, p, q): """ :type p: TreeNode :type q: TreeNode :rtype: bool """ # 定义内部函数，用于判断两个节点是否相同 def check(p, q): # if both are None if not p and not q: return True # one of p and q is None if not q or not p: return False if p.val != q.val: return False return True # 使用队列，先将p和q的根节点作为pair元组加入队列（按对加入很重要） deq = deque([(p, q),]) # 当队列中还有pair的时候，就要进行比对，知道队列为空，或者出现不同的对 while deq: # 一对一对拿出来比对 p, q = deq.popleft() # 只要有一对不同，则返回false if not check(p, q): return False # 只要p树还有节点 if p: # 将p的左 q的左做成一对加入队列 deq.append((p.left, q.left)) # 将p的右 q的右做成一对加入队列 deq.append((p.right, q.right)) return True
迭代解法。
时间复杂度 : O(N)，其中 N 是树的结点数，因为每个结点都访问一次。
空间复杂度 : 最优情况（完全平衡二叉树）时为 O(log(N))，最坏情况下（完全不平衡二叉树）时为 O(N)。
总结：
# 递归做法比较简洁，但是每轮递归都要开辟栈空间。 # 迭代做法利用了一个队列，由于比较树形结构，所以将其对应节点做为pair是非常好的思想
4.对称二叉树
题目：
给定一个二叉树，检查它是否是镜像对称的。
说明:
如果你可以运用递归和迭代两种方法解决这个问题，会很加分。
示例：
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。 1 / 2 2 / / 3 4 4 3 但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的: 1 / 2 2 3 3
代码1：
class Solution: def isSymmetric(self, root: TreeNode) -> bool: # 递归，传入判断是否对称的两个节点 def ismirror(left,right): # 如果都为空，表示对称 if not left and not right: return True # 如果只有一个为空，则不对称 if not left or not right: return False # 如果都不为空，但val不同，也不对称 if left.val != right.val: return False # 在当前两个节点对称的情况下，分别在求他们的子节点的是否都对称 return ismirror(left.left, right.right) and ismirror(left.right,right.left) return ismirror(root,root)
递归解法。
代码2：
class Solution: def isSymmetric(self, root: TreeNode) -> bool: from collections import deque if not root: return True deq = deque([(root.left, root.right),]) # st=[root.left,root.right] while deq: l,r=deq.popleft() if not l and not r: continue elif not l or not r: return False elif l.val!=r.val: return False else: deq.append((l.left,r.right)) deq.append((l.right,r.left)) return True
迭代做法，和前面的第3题一样，差不多的思路。
总结：
# 二叉树是否对称和前面第3题（两个二叉树是否相等）思路基本一致 # 二叉树是否对称，可以看成 自己和自己的镜像是否完全相等 # 所以两道题的递归做法和迭代做法都是很相似的
###