code

Author: MyHerux

LeetCode/排序算法/1356_根据数字二进制下 1 的数目排序.md

@@ -0,0 +1,99 @@
+## 题目描述
+
+给你一个整数数组 arr 。请你将数组中的元素按照其二进制表示中数字 1 的数目升序排序。
+
+如果存在多个数字二进制中 1 的数目相同，则必须将它们按照数值大小升序排列。
+
+请你返回排序后的数组。
+
+**示例 1：**
+
+```
+输入：arr = [0,1,2,3,4,5,6,7,8]
+输出：[0,1,2,4,8,3,5,6,7]
+解释：[0] 是唯一一个有 0 个 1 的数。
+[1,2,4,8] 都有 1 个 1 。
+[3,5,6] 有 2 个 1 。
+[7] 有 3 个 1 。
+按照 1 的个数排序得到的结果数组为 [0,1,2,4,8,3,5,6,7]
+```
+
+**示例 2：**
+
+```
+输入：arr = [1024,512,256,128,64,32,16,8,4,2,1]
+输出：[1,2,4,8,16,32,64,128,256,512,1024]
+解释：数组中所有整数二进制下都只有 1 个 1 ，所以你需要按照数值大小将它们排序。
+```
+
+**示例 3：**
+
+```
+输入：arr = [10000,10000]
+输出：[10000,10000]
+```
+
+**示例 4：**
+
+```
+输入：arr = [2,3,5,7,11,13,17,19]
+输出：[2,3,5,17,7,11,13,19]
+```
+
+**示例 5：**
+
+```
+输入：arr = [10,100,1000,10000]
+输出：[10,100,10000,1000]
+```
+
+**提示：**
+
+- 1 <= arr.length <= 500
+- 0 <= arr[i] <= 10^4
+
+## 方法一：暴力
+
+对每个十进制的数转二进制的时候统计二进制表示中的 1 的个数即可。
+
+## 方法二：递推预处理
+我们定义 bit[i] 为数字 i 二进制表示下数字 1 的个数，则可以列出递推式：
+
+bit[i]=bit[i>>1]+(i&1)
+
+所以我们线性预处理 bitbit 数组然后去排序即可。
+
+```
+class Solution {
+    public int[] sortByBits(int[] arr) {
+        List<Integer> list = new ArrayList<Integer>();
+        for (int x : arr) {
+            list.add(x);
+        }
+        int[] bit = new int[10001];
+        for (int i = 1; i <= 10000; ++i) {
+            bit[i] = bit[i >> 1] + (i & 1);
+        }
+        Collections.sort(list, new Comparator<Integer>() {
+            public int compare(Integer x, Integer y) {
+                if (bit[x] != bit[y]) {
+                    return bit[x] - bit[y];
+                } else {
+                    return x - y;
+                }
+            }
+        });
+        for (int i = 0; i < arr.length; ++i) {
+            arr[i] = list.get(i);
+        }
+        return arr;
+    }
+}
+```
+
+### 复杂度分析
+
+- 时间复杂度：O(nlogn)，其中 n 为整数数组 arr 的长度。
+
+- 空间复杂度：O(n)，其中 n 为整数数组 arr 的长度。
+

LeetCode/排序算法/1502_判断能否形成等差数列.md

@@ -0,0 +1,53 @@
+## 题目描述
+
+给你一个数字数组 arr 。
+
+如果一个数列中，任意相邻两项的差总等于同一个常数，那么这个数列就称为 等差数列 。
+
+如果可以重新排列数组形成等差数列，请返回 true ；否则，返回 false 。
+
+
+**示例 1：**
+
+```
+输入：arr = [3,5,1]
+输出：true
+解释：对数组重新排序得到 [1,3,5] 或者 [5,3,1] ，任意相邻两项的差分别为 2 或 -2 ，可以形成等差数列。
+```
+
+**示例 2：**
+
+```
+输入：arr = [1,2,4]
+输出：false
+解释：无法通过重新排序得到等差数列。
+```
+
+**提示：**
+
+- 2 <= arr.length <= 1000
+- -10^6 <= arr[i] <= 10^6
+
+## 方法一：模拟
+
+首先我们对原序列排序，假设排序之后序列为{a0,a1,⋯an}，如果对 i∈[1,n−1] 中的每个数都有 a_i x 2 = a_{i - 1} + a_{i + 1}成立，那么这个数列就是等差数列。
+
+```
+class Solution {
+    public boolean canMakeArithmeticProgression(int[] arr) {
+        Arrays.sort(arr);
+        for (int i = 1; i < arr.length - 1; ++i) {
+            if (arr[i] * 2 != arr[i - 1] + arr[i + 1]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
+### 复杂度分析
+
+- 时间复杂度：O(nlogn)。排序的时间代价为 O(nlogn)，遍历序列的时间代价是 O(n)，故渐进时间复杂度为 O(nlogn+n)=O(nlogn)。
+- 空间复杂度：O(logn)。快速排序中使用的栈空间期望是 O(logn)。
+

LeetCode/排序算法/922_按奇偶排序数组_II.md

@@ -0,0 +1,97 @@
+## 题目描述
+
+给定一个非负整数数组 A， A 中一半整数是奇数，一半整数是偶数。
+
+对数组进行排序，以便当 A[i] 为奇数时，i 也是奇数；当 A[i] 为偶数时， i 也是偶数。
+
+你可以返回任何满足上述条件的数组作为答案。
+
+ 
+
+**示例：**
+
+```
+输入：[4,2,5,7]
+输出：[4,5,2,7]
+解释：[4,7,2,5]，[2,5,4,7]，[2,7,4,5] 也会被接受。
+```
+
+**提示：**
+
+- 2 <= A.length <= 20000
+- A.length % 2 == 0
+- 0 <= A[i] <= 1000
+
+## 方法一： 两次遍历
+
+遍历一遍数组把所有的偶数放进 ans[0]，ans[2]，ans[4]，依次类推。
+
+再遍历一遍数组把所有的奇数依次放进 ans[1]，ans[3]，ans[5]，依次类推。
+
+```
+class Solution {
+    public int[] sortArrayByParityII(int[] A) {
+        int n = A.length;
+        int[] ans = new int[n];
+
+        int i = 0;
+        for (int x : A) {
+            if (x % 2 == 0) {
+                ans[i] = x;
+                i += 2;
+            }
+        }
+        i = 1;
+        for (int x : A) {
+            if (x % 2 == 1) {
+                ans[i] = x;
+                i += 2;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### 复杂度分析
+
+- 时间复杂度：O(N)，其中 N 是数组 A 的长度。
+
+- 空间复杂度：O(1)。注意在这里我们不考虑输出数组的空间占用。
+
+## 方法二： 双指针
+
+如果原数组可以修改，则可以使用就地算法求解。
+
+为数组的偶数下标部分和奇数下标部分分别维护指针 i,j。随后，在每一步中，如果A[i] 为奇数，则不断地向前移动 j（每次移动两个单位），直到遇见下一个偶数。此时，可以直接将 A[i] 与 A[j] 交换。我们不断进行这样的过程，最终能够将所有的整数放在正确的位置上。
+
+```
+class Solution {
+    public int[] sortArrayByParityII(int[] A) {
+        int n = A.length;
+        int j = 1;
+        for (int i = 0; i < n; i += 2) {
+            if (A[i] % 2 == 1) {
+                while (A[j] % 2 == 1) {
+                    j += 2;
+                }
+                swap(A, i, j);
+            }
+        }   
+        return A;
+    }
+
+    public void swap(int[] A, int i, int j) {
+        int temp = A[i];
+        A[i] = A[j];
+        A[j] = temp;
+    }
+}
+```
+
+### 复杂度分析
+
+- 时间复杂度：O(N)，其中 N 是数组 A 的长度。
+
+- 空间复杂度：O(1)。
+