一刷164

Author: diguage

README.adoc

@@ -1173,13 +1173,13 @@ TIP: **公众号的微信号是: `jikerizhi`**。__因为众所周知的原因
 //|{doc_base_url}/0163-missing-ranges.adoc[题解]
 //|Medium
 //|
-//
-//|{counter:codes}
-//|{leetcode_base_url}/maximum-gap/[164. Maximum Gap^]
-//|{source_base_url}/_0164_MaximumGap.java[Java]
-//|{doc_base_url}/0164-maximum-gap.adoc[题解]
-//|Hard
-//|
+
+|{counter:codes}
+|{leetcode_base_url}/maximum-gap/[164. Maximum Gap^]
+|{source_base_url}/_0164_MaximumGap.java[Java]
+|{doc_base_url}/0164-maximum-gap.adoc[题解]
+|Hard
+|
 
 |{counter:codes}
 |{leetcode_base_url}/compare-version-numbers/[165. Compare Version Numbers^]

docs/0164-maximum-gap.adoc

@@ -1,43 +1,65 @@
 [#0164-maximum-gap]
-= 164. Maximum Gap
+= 164. 最大间距
 
-{leetcode}/problems/maximum-gap/[LeetCode - Maximum Gap^]
+https://leetcode.cn/problems/maximum-gap/[LeetCode - 164. 最大间距 ^]
 
-Given an unsorted array, find the maximum difference between the successive elements in its sorted form.
+给定一个无序的数组 `nums`，返回 _数组在排序之后，相邻元素之间最大的差值_。如果数组元素个数小于 2，则返回 `0` 。
 
-Return 0 if the array contains less than 2 elements.
+您必须编写一个在「线性时间」内运行并使用「线性额外空间」的算法。
 
-*Example 1:*
+*示例 1:*
 
-[subs="verbatim,quotes,macros"]
-----
-*Input:* [3,6,9,1]
-*Output:* 3
-*Explanation:* The sorted form of the array is [1,3,6,9], either
-             (3,6) or (6,9) has the maximum difference 3.
-----
+....
+输入: nums = [3,6,9,1]
+输出: 3
+解释: 排序后的数组是 [1,3,6,9], 其中相邻元素 (3,6) 和 (6,9) 之间都存在最大差值 3。
+....
 
-*Example 2:*
+*示例 2:*
 
-[subs="verbatim,quotes,macros"]
-----
-*Input:* [10]
-*Output:* 0
-*Explanation:* The array contains less than 2 elements, therefore return 0.
-----
+....
+输入: nums = [10]
+输出: 0
+解释: 数组元素个数小于 2，因此返回 0。
+....
 
-*Note:*
+*提示:*
 
+* `1 \<= nums.length \<= 10^5^`
+* `0 \<= nums[i] \<= 10^9^`
 
-* You may assume all elements in the array are non-negative integers and fit in the 32-bit signed integer range.
-* Try to solve it in linear time/space.
 
+== 思路分析
 
+使用比特位表示每个数字！这样统计每个比特位之间的差值即可。
 
+使用比特位并不是最优解，内存消耗可能比较大。看题解，应该使用基数排序。抽空学习一下！
 
 [[src-0164]]
+[tabs]
+====
+一刷::
++
+--
 [{java_src_attr}]
 ----
 include::{sourcedir}/_0164_MaximumGap.java[tag=answer]
 ----
+--
+
+// 二刷::
+// +
+// --
+// [{java_src_attr}]
+// ----
+// include::{sourcedir}/_0164_MaximumGap_2.java[tag=answer]
+// ----
+// --
+====
+
+
+== 参考资料
+
+
+
 

docs/index.adoc

@@ -411,7 +411,7 @@ include::0162-find-peak-element.adoc[leveloffset=+1]
 
 // include::0163-missing-ranges.adoc[leveloffset=+1]
 
-// include::0164-maximum-gap.adoc[leveloffset=+1]
+include::0164-maximum-gap.adoc[leveloffset=+1]
 
 include::0165-compare-version-numbers.adoc[leveloffset=+1]
 

logbook/202503.adoc

@@ -1083,6 +1083,11 @@ endif::[]
 |{doc_base_url}/0174-dungeon-game.adoc[题解]
 |✅ 动态规划！从终点向起始位置反推。遇到正数就直接加，遇到负数则先看看上一步的最大值是正数还是负数，是负数则需要累加，是正数则舍弃，直接从当前位置的负数算起。
 
+|{counter:codes2503}
+|{leetcode_base_url}/maximum-gap/[164. 最大间距^]
+|{doc_base_url}/0164-maximum-gap.adoc[题解]
+|✅ 使用比特位表示每个数字！这样统计每个比特位之间的差值即可。更优解是基数排序，抽空学习一下。
+
 |===
 
 截止目前，本轮练习一共完成 {codes2503} 道题。

src/main/java/com/diguage/algo/leetcode/_0162_FindPeakElement.java

@@ -49,6 +49,9 @@ public class _0162_FindPeakElement {
      * Memory Usage: 38.4 MB, less than 100.00% of Java online submissions for Find Peak Element.
      *
      * Copy form: https://leetcode.com/problems/find-peak-element/solution/[Find Peak Element solution - LeetCode]
+     *
+     * @author D瓜哥 · https://www.diguage.com
+     * @since 2020-01-05 11:03
      */
     public int findPeakElement(int[] nums) {
         return search(nums, 0, nums.length - 1);

src/main/java/com/diguage/algo/leetcode/_0164_MaximumGap.java

@@ -0,0 +1,61 @@
+package com.diguage.algo.leetcode;
+
+import java.util.Arrays;
+
+public class _0164_MaximumGap {
+  // tag::answer[]
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-06-29 11:13:03
+   */
+  public int maximumGap(int[] nums) {
+    int max = Arrays.stream(nums).max().orElse(0);
+    long[] bits = new long[max / 64 + 1];
+    for (int num : nums) {
+      int index = num / 64;
+      int step = num % 64;
+      bits[index] = bits[index] | (1L << step);
+    }
+    int result = 0;
+    int pre = -1;
+    for (int i = 0; i < bits.length; i++) {
+      long bit = bits[i];
+      if (bit == 0) {
+        continue;
+      }
+      int step = 0;
+      int start = i * 64;
+      while (bit != 0) {
+        if ((bit & 1) == 1) {
+          if (pre == -1) {
+            pre = start + step;
+          } else {
+            int next = start + step;
+            result = Math.max(result, next - pre);
+            pre = next;
+          }
+        }
+        step++;
+        // 注意：这里要使用 >>> 无符号右移
+        bit >>>= 1;
+      }
+
+    }
+    return result;
+  }
+
+  //  // 最简单的写法
+  //  public int maximumGap(int[] nums) {
+  //    Arrays.sort(nums);
+  //    int result = 0;
+  //    for (int i = 1; i < nums.length; i++) {
+  //      result = Math.max(result, nums[i] - nums[i - 1]);
+  //    }
+  //    return result;
+  //  }
+
+  // end::answer[]
+  public static void main(String[] args) {
+    new _0164_MaximumGap().maximumGap(new int[]{2, 99999999});
+  }
+}