算法基础打卡

@[TOC]20天算法基础打卡

力扣20天算法基础打卡

为了应对大厂面试，对于算法部分，需要天天打卡，加油加油！

No.1day 广度优先搜索 / 深度优先搜索

733. 图像渲染
有一幅以二维整数数组表示的图画，每一个整数表示该图画的像素值大小，数值在 0 到 65535 之间。
给你一个坐标 (sr, sc) 表示图像渲染开始的像素值（行 ，列）和一个新的颜色值 newColor，让你重新上色这幅图像。
为了完成上色工作，从初始坐标开始，记录初始坐标的上下左右四个方向上像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应四个方向上像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为新的颜色值。
最后返回经过上色渲染后的图像。

1. 思路及算法：
   我们从给定的起点开始，进行深度优先搜索。每次搜索到一个方格时，如果其与初始位置的方格颜色相同，就将该方格的颜色更新，以防止重复搜索；如果不相同，则进行回溯。
   注意：因为初始位置的颜色会被修改，所以我们需要保存初始位置的颜色，以便于之后的更新操作。
2. 代码：

class Solution:
 def floodFill(self, image: List[List[int]], sr: int, sc: int, newColor: int) -> List[List[int]]:
  n=len(image)
  m=len(image[0])
  color=image[sr][sc]
  if color==newColor:
  	return image
  def dfs(int p,int q):
  	if image[p][q]==color:
  		image[p][q]=newColor
  		if p>=1:
  			dfs(p-1,q)
  		if p+1<n:
  			dfs(p+1,q)
  		if q>=1:
  			dfs(p,q-1)
  		if q+1<m:
  			dfs(p,q+1)
   dfs(sr,sc)
   return image
  
  		
  	

617. 合并二叉树
给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-two-binary-trees
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1. 思路及算法：
   我们从给定的起点开始，进行深度优先搜索。会出现一下三种情况：
   1.当两个树一个节点为空，一个节点不为空时，则合并之后的节点值等于不为空那个数。
   2.当两个数节点都不为空时，则合并之后的节点值等于两个树的节点值相加。
   3.如果两个二叉树的对应节点都为空，则合并后的二叉树的对应节点也为空；
2. 代码：

class Solution:
  def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
      if not root1:
          return root2
      if not root2:
          return root1
      merged=TreeNode(root1.val+root2.val)
      merged.left=self.mergeTrees(root1.left,root2.left)
      merged.right=self.mergeTrees(root1.right,root2.right)
      return merged

116. 层次遍历二叉树
填充每个节点的下一个右侧节点指针。给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
1. 代码：

class Solution:
   def connect(self, root: 'Node') -> 'Node':
       if not root:
           return root
       #新建一个队列，并把根节点插入到队列中去
       q=collections.deque([root])
       while q:
           size=len(q)
           for i in range(size):
               #把队列的头节点输出
               node=q.popleft()
               if i<size-1:
                   node.next=q[0]
               if node.left:
                       q.append(node.left)
               if node.right:
                       q.append(node.right)
       return root

21. 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
1. 代码：

 class Solution:
   def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
       if not l1:
           return l2
       if not l2:
           return l1
       if l1.val<l2.val:
           l1.next=self.mergeTwoLists(l1.next,l2)
           return l1
       else:
           l2.next=self.mergeTwoLists(l1,l2.next)
           return l2

88. 合并两个有序数组
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

1. 代码：

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.
       """
       nums1[:]=sorted(nums1[:m]+nums2)
       return nums1

206反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
1. 代码：

class Solution:
   def reverseList(self, head: ListNode) -> ListNode:
       prev=None#新建链表的头节点
       cur=head#原链表的头节点
       while cur:
           next=cur.next#记录原链表的头节点的下一个节点
           cur.next=prev#改变链表的方向
           prev=cur
           cur=next
       return prev