update

Author: CongLinDev

0167-两数之和 II - 输入有序数组.md

@@ -0,0 +1,41 @@
+# 两数之和 II - 输入有序数组
+
+## 题目描述
+
+给定一个已按照 **升序排列** 的有序数组，找到两个数使得它们相加之和等于目标数。
+
+函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。
+
+* 返回的下标值（index1 和 index2）不是从零开始的。
+* 你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。
+
+```
+输入: numbers = [2, 7, 11, 15], target = 9
+输出: [1,2]
+解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。
+```
+
+## 分析
+
+双指针寻找结果即可。
+
+## 算法
+
+```java
+
+class Solution {
+    public int[] twoSum(int[] numbers, int target) {
+        int left = 0, right = numbers.length - 1;
+        while(left < right){
+            if(numbers[left] + numbers[right] == target){
+                return new int[]{left + 1, right + 1};
+            }else if(numbers[left] + numbers[right] < target){
+                left++;
+            }else{
+                right--;
+            }
+        }
+        return new int[0];
+    }
+}
+```

0189-旋转数组.md

@@ -0,0 +1,56 @@
+# 旋转数组
+
+## 题目描述
+
+给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
+
+```
+输入: [1,2,3,4,5,6,7] 和 k = 3
+输出: [5,6,7,1,2,3,4]
+解释:
+向右旋转 1 步: [7,1,2,3,4,5,6]
+向右旋转 2 步: [6,7,1,2,3,4,5]
+向右旋转 3 步: [5,6,7,1,2,3,4]
+
+输入: [-1,-100,3,99] 和 k = 2
+输出: [3,99,-1,-100]
+解释: 
+向右旋转 1 步: [99,-1,-100,3]
+向右旋转 2 步: [3,99,-1,-100]
+```
+
+* 尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
+* 要求使用空间复杂度为 O(1) 的 原地 算法。
+
+## 分析
+
+将整个数组翻转后，在根据k的值将数组分割为两个数组分别翻转即可。
+
+```
+例如 [1,2,3,4,5,6,7] 和 k = 3
+
+第一次翻转 为 [7,6,5,4,3,2,1]
+k = 3， 将数组分割为 0-2 和 3-6 分别翻转 结果为 [5,6,7,1,2,3,4]
+```
+
+## 算法
+
+```java
+class Solution {
+    public void rotate(int[] nums, int k) {
+        int len = nums.length;
+        k %= len;
+        reverse(nums, 0, len - 1);
+        reverse(nums, 0, k - 1);
+        reverse(nums, k, len - 1);
+    }
+
+    private void reverse(int[] nums, int start, int end){
+        while(start < end){
+            int temp = nums[start];
+            nums[start++] = nums[end];
+            nums[end--] = temp;
+        }
+    }
+}
+```

0197-SQL-上升的温度.md

@@ -0,0 +1,36 @@
+# SQL-上升的温度
+
+## 题目描述
+
+给定一个 Weather 表，编写一个 SQL 查询，来查找与之前（昨天的）日期相比温度更高的所有日期的 Id。
+
+```
++---------+------------------+------------------+
+| Id(INT) | RecordDate(DATE) | Temperature(INT) |
++---------+------------------+------------------+
+|       1 |       2015-01-01 |               10 |
+|       2 |       2015-01-02 |               25 |
+|       3 |       2015-01-03 |               20 |
+|       4 |       2015-01-04 |               30 |
++---------+------------------+------------------+
+```
+
+例如，根据上述给定的 Weather 表格，返回如下 Id:
+
+```
++----+
+| Id |
++----+
+|  2 |
+|  4 |
++----+
+```
+
+## SQL
+
+```sql
+select a.Id from Weather as a
+    join Weather as b
+        on a.Temperature > b.Temperature
+        and dateDiff(a.RecordDate, b.RecordDate) = 1
+```

0199-二叉树的右视图.md

@@ -0,0 +1,55 @@
+# 二叉树的右视图
+
+## 题目描述
+
+给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
+
+```
+输入: [1,2,3,null,5,null,4]
+输出: [1, 3, 4]
+解释:
+
+   1            <---
+ /   \
+2     3         <---
+ \     \
+  5     4       <---
+```
+
+## 分析
+
+层序遍历，将每一层的最后一个元素加入结果集合中即可。
+
+## 算法
+
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public List<Integer> rightSideView(TreeNode root) {
+        List<Integer> list = new ArrayList<>();
+        if(root == null) return list;
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+        while(!queue.isEmpty()){
+            int count = queue.size();
+            TreeNode node = null;
+            while(count-- != 0){
+                node = queue.poll();
+                if(node.left != null) queue.offer(node.left);
+                if(node.right != null) queue.offer(node.right);
+            }
+            list.add(node.val);
+        }
+        return list;
+    }
+}
+```

0201-数字范围按位与.md

@@ -0,0 +1,38 @@
+# 数字范围按位与
+
+## 题目描述
+
+给定范围 [m, n]，其中 0 <= m <= n <= 2147483647，返回此范围内所有数字的按位与（包含 m, n 两端点）。
+
+```
+输入: [5,7]
+输出: 4
+
+输入: [0,1]
+输出: 0
+```
+
+## 分析
+
+当一个数+1时，总会有这么一个规律“某一位后的数字，全部被置为相反数”。
+
+举个例子：010111 + 1 = 011000，则010111 & 011000 = 010000。那么，x & (x+1) 后几位相反数的“与操作”，结果总为0。
+
+所以，当(m,m+1,...n-1,n)进行连续“与操作”时，会按照上述规律被抵消很大一部分，而只剩下n的前缀部分，最后只需将n归位。
+
+举个例子：m = 5(0101), n = 7 (0111)。不停右移，得到n前缀部分为01，最后归位前缀得res=0100=4。
+
+## 算法
+
+```java
+class Solution {
+    public int rangeBitwiseAnd(int m, int n) {
+        int offset = 0;
+        for(; m != n; offset++){
+            m >>= 1;
+            n >>= 1;
+        }
+        return n << offset;
+    }
+}
+```