Merge branch 'youngyangyang04:master' into master

problems/0024.两两交换链表中的节点.md

@@ -86,6 +86,34 @@ public:
 
 ## 其他语言版本
 
+C:
+```
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     struct ListNode *next;
+ * };
+ */
+
+
+struct ListNode* swapPairs(struct ListNode* head){
+    //使用双指针避免使用中间变量
+    typedef struct ListNode ListNode;
+    ListNode *fakehead = (ListNode *)malloc(sizeof(ListNode));
+    fakehead->next = head;
+    ListNode* right = fakehead->next;
+    ListNode* left = fakehead;
+    while(left && right && right->next ){
+        left->next = right->next;
+        right->next = left->next->next;
+        left->next->next = right;
+        left = right;
+        right = left->next;
+    }
+    return fakehead->next;
+}
+```
 
 Java：
 

problems/0034.在排序数组中查找元素的第一个和最后一个位置.md

@@ -50,7 +50,7 @@
 
 接下来，在去寻找左边界，和右边界了。
 
-采用二分法来取寻找左右边界，为了让代码清晰，我分别写两个二分来寻找左边界和右边界。
+采用二分法来去寻找左右边界，为了让代码清晰，我分别写两个二分来寻找左边界和右边界。
 
 **刚刚接触二分搜索的同学不建议上来就像如果用一个二分来查找左右边界，很容易把自己绕进去，建议扎扎实实的写两个二分分别找左边界和右边界**
 
@@ -275,6 +275,117 @@ class Solution {
 ## Python
 
 ```python
+class Solution:
+    def searchRange(self, nums: List[int], target: int) -> List[int]:
+        def getRightBorder(nums:List[int], target:int) -> int:
+            left, right = 0, len(nums)-1
+            rightBoder = -2 # 记录一下rightBorder没有被赋值的情况
+            while left <= right:
+                middle = left + (right-left) // 2
+                if nums[middle] > target:
+                    right = middle - 1
+                else: # 寻找右边界，nums[middle] == target的时候更新left
+                    left = middle + 1
+                    rightBoder = left
+    
+            return rightBoder
+        
+        def getLeftBorder(nums:List[int], target:int) -> int:
+            left, right = 0, len(nums)-1 
+            leftBoder = -2 # 记录一下leftBorder没有被赋值的情况
+            while left <= right:
+                middle = left + (right-left) // 2
+                if nums[middle] >= target: #  寻找左边界，nums[middle] == target的时候更新right
+                    right = middle - 1;
+                    leftBoder = right;
+                else:
+                    left = middle + 1
+            return leftBoder
+        leftBoder = getLeftBorder(nums, target)
+        rightBoder = getRightBorder(nums, target)
+        # 情况一
+        if leftBoder == -2 or rightBoder == -2: return [-1, -1]
+        # 情况三
+        if rightBoder -leftBoder >1: return [leftBoder + 1, rightBoder - 1]
+        # 情况二
+        return [-1, -1]
+```
+```python
+# 解法2
+# 1、首先，在 nums 数组中二分查找 target；
+# 2、如果二分查找失败，则 binarySearch 返回 -1，表明 nums 中没有 target。此时，searchRange 直接返回 {-1, -1}；
+# 3、如果二分查找成功，则 binarySearch 返回 nums 中值为 target 的一个下标。然后，通过左右滑动指针，来找到符合题意的区间
+class Solution:
+    def searchRange(self, nums: List[int], target: int) -> List[int]:
+        def binarySearch(nums:List[int], target:int) -> int:
+            left, right = 0, len(nums)-1
+            while left<=right: # 不变量：左闭右闭区间
+                middle = left + (right-left) // 2
+                if nums[middle] > target:
+                    right = middle - 1
+                elif nums[middle] < target: 
+                    left = middle + 1
+                else:
+                    return middle
+            return -1
+        index = binarySearch(nums, target)
+        if index == -1:return [-1, -1] # nums 中不存在 target，直接返回 {-1, -1}
+        # nums 中存在 targe，则左右滑动指针，来找到符合题意的区间
+        left, right = index, index
+        # 向左滑动，找左边界
+        while left -1 >=0 and nums[left - 1] == target: left -=1
+        # 向右滑动，找右边界
+        while right+1 < len(nums) and nums[right + 1] == target: right +=1
+        return [left, right]
+```
+```python
+# 解法3
+# 1、首先，在 nums 数组中二分查找得到第一个大于等于 target的下标（左边界）与第一个大于target的下标（右边界）；
+# 2、如果左边界<= 右边界，则返回 [左边界, 右边界]。否则返回[-1, -1]
+class Solution:
+    def searchRange(self, nums: List[int], target: int) -> List[int]:
+        def binarySearch(nums:List[int], target:int, lower:bool) -> int:
+            left, right = 0, len(nums)-1
+            ans = len(nums)
+            while left<=right: # 不变量：左闭右闭区间
+                middle = left + (right-left) //2 
+                # lower为True，执行前半部分，找到第一个大于等于 target的下标 ，否则找到第一个大于target的下标
+                if nums[middle] > target or (lower and nums[middle] >= target): 
+                    right = middle - 1
+                    ans = middle
+                else: 
+                    left = middle + 1
+            return ans
+
+        leftBorder = binarySearch(nums, target, True) # 搜索左边界
+        rightBorder = binarySearch(nums, target, False) -1  # 搜索右边界
+        if leftBorder<= rightBorder and rightBorder< len(nums) and nums[leftBorder] == target and  nums[rightBorder] == target:
+            return [leftBorder, rightBorder]
+        return [-1, -1]
+```
+
+```python
+# 解法4
+# 1、首先，在 nums 数组中二分查找得到第一个大于等于 target的下标leftBorder；
+# 2、在 nums 数组中二分查找得到第一个大于等于 target+1的下标， 减1则得到rightBorder；
+# 3、如果开始位置在数组的右边或者不存在target，则返回[-1, -1] 。否则返回[leftBorder, rightBorder]
+class Solution:
+    def searchRange(self, nums: List[int], target: int) -> List[int]:
+        def binarySearch(nums:List[int], target:int) -> int:
+            left, right = 0, len(nums)-1
+            while left<=right: # 不变量：左闭右闭区间
+                middle = left + (right-left) //2 
+                if nums[middle] >= target: 
+                    right = middle - 1
+                else: 
+                    left = middle + 1
+            return left  # 若存在target，则返回第一个等于target的值 
+
+        leftBorder = binarySearch(nums, target) # 搜索左边界
+        rightBorder = binarySearch(nums, target+1) -1  # 搜索右边界
+        if leftBorder == len(nums) or nums[leftBorder]!= target: # 情况一和情况二
+            return [-1, -1]
+        return [leftBorder, rightBorder]
 ```
 
 ## Go

problems/0102.二叉树的层序遍历.md

@@ -1254,6 +1254,44 @@ func connect(root *Node) *Node {
 }
 ```
 
+Java 代码：
+
+```java
+// 二叉树之层次遍历
+class Solution {
+    public Node connect(Node root) {
+        Queue<Node> queue = new LinkedList<>();
+        if (root != null) {
+            queue.add(root);
+        }
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            Node node = null;
+            Node nodePre = null;
+ 
+            for (int i = 0; i < size; i++) {
+                if (i == 0) {
+                    nodePre = queue.poll(); // 取出本层头一个节点
+                    node = nodePre;
+                } else {
+                    node = queue.poll();
+                    nodePre.next = node; // 本层前一个节点 next 指向当前节点
+                    nodePre = nodePre.next;
+                }
+                if (node.left != null) {
+                    queue.add(node.left);
+                }
+                if (node.right != null) {
+                    queue.add(node.right);
+                }
+            }
+            nodePre.next = null; // 本层最后一个节点 next 指向 null
+        }
+        return root;
+    }
+}
+```
+
 ## 117.填充每个节点的下一个右侧节点指针II
 
 题目地址：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii/