Java詳解LeetCode 熱題 100(15):LeetCode 189. 輪轉數組（Rotate Array）詳解

文章目錄

    • 1. 題目描述
    • 2. 理解題目
    • 3. 解法一：使用額外數組
      • 3.1 思路
      • 3.2 Java代碼實現
      • 3.3 代碼詳解
      • 3.4 復雜度分析
      • 3.5 適用場景
    • 4. 解法二：環狀替換法（原地算法）
      • 4.1 思路
      • 4.2 Java代碼實現
      • 4.3 代碼詳解
      • 4.4 復雜度分析
      • 4.5 陷阱與注意事項
    • 5. 解法三：數組翻轉法（最優原地算法）
      • 5.1 思路
      • 5.2 Java代碼實現
      • 5.3 代碼詳解
      • 5.4 數學證明
      • 5.5 復雜度分析
      • 5.6 適用場景
    • 6. 詳細步驟分析與示例跟蹤
      • 6.1 示例跟蹤：使用額外數組法
      • 6.2 示例跟蹤：環狀替換法
      • 6.3 示例跟蹤：數組翻轉法
    • 7. 常見錯誤與優化
      • 7.1 常見錯誤
      • 7.2 優化技巧
    • 8. 三種解法的對比與選擇
    • 9. 擴展題目與應用
      • 9.1. 左輪轉數組
      • 9.2. 字符串輪轉
      • 9.3. 循環移位操作
    • 10. 實際應用場景
    • 11. 完整的 Java 解決方案
    • 12. 總結與技巧
      • 12.1 解題要點
      • 12.2 學習收獲
      • 12.3 面試技巧
    • 13. 參考資料

1. 題目描述

給你一個數組，將數組中的元素向右輪轉 k 個位置，其中 k 是非負數。

示例 1:

輸入: nums = [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]

示例 2:

輸入：nums = [-1,-100,3,99], k = 2
輸出：[3,99,-1,-100]
解釋: 
向右輪轉 1 步: [99,-1,-100,3]
向右輪轉 2 步: [3,99,-1,-100]

提示：

  • 1 <= nums.length <= 10^5
  • -2^31 <= nums[i] <= 2^31 - 1
  • 0 <= k <= 10^5

進階：

  • 盡可能想出更多的解決方案，至少有三種不同的方法可以解決這個問題。
  • 你可以使用空間復雜度為 O(1) 的 原地 算法解決這個問題嗎？

2. 理解題目

這道題要求我們將數組中的所有元素向右移動k個位置。具體來說：

  • 數組中的每個元素都向右移動k個索引位置
  • 數組是"循環"的，即超出數組末尾的元素會被放置到數組的開頭
  • 我們需要原地修改數組，而不是創建一個新數組（盡管也可以使用額外空間的解法）

關鍵點：

  1. k可能大于數組長度，因此實際的移動次數是k % n（其中n是數組長度）
  2. 向右輪轉k次等同于將數組最后k個元素移動到數組開頭
  3. 這道題可以有多種解法，包括使用額外空間和原地（O(1)空間復雜度）算法

3. 解法一：使用額外數組

3.1 思路

最簡單直觀的方法是創建一個新數組，然后將原數組的每個元素放到新數組中的正確位置：

  1. 創建一個與原數組相同大小的新數組
  2. 對于原數組中索引為i的元素，其在新數組中的位置為(i + k) % n
  3. 將新數組的內容復制回原數組

這種方法使用了O(n)的額外空間，但思路非常清晰，適合初學者理解。

3.2 Java代碼實現

class Solution {public void rotate(int[] nums, int k) {int n = nums.length;// 處理 k 大于數組長度的情況k = k % n;// 如果k為0，不需要輪轉if (k == 0) {return;}// 創建一個新數組來存儲輪轉后的結果int[] result = new int[n];// 將原數組中的元素放入新數組的正確位置for (int i = 0; i < n; i++) {result[(i + k) % n] = nums[i];}// 將新數組的內容復制回原數組for (int i = 0; i < n; i++) {nums[i] = result[i];}}
}

3.3 代碼詳解

詳細解釋每一步的意義和實現：

int n = nums.length;// 處理 k 大于數組長度的情況
k = k % n;// 如果k為0，不需要輪轉
if (k == 0) {return;
}
  • 首先獲取數組長度n
  • 由于輪轉n次會回到原始狀態，所以我們只需要考慮k % n次輪轉
  • 如果k為0或者k是n的倍數，數組不需要變化，直接返回
// 創建一個新數組來存儲輪轉后的結果
int[] result = new int[n];// 將原數組中的元素放入新數組的正確位置
for (int i = 0; i < n; i++) {result[(i + k) % n] = nums[i];
}
  • 創建一個與原數組相同大小的新數組
  • 將原數組中索引為i的元素放到新數組中索引為(i + k) % n的位置
  • 這里使用模運算是為了處理索引超出數組長度的情況
// 將新數組的內容復制回原數組
for (int i = 0; i < n; i++) {nums[i] = result[i];
}
  • 最后，將臨時數組中的結果復制回原數組，完成輪轉操作

3.4 復雜度分析

  • 時間復雜度: O(n)，其中n是數組的長度。我們需要遍歷數組兩次，每次遍歷的時間復雜度是O(n)。
  • 空間復雜度: O(n)，我們創建了一個與原數組等長的新數組。

3.5 適用場景

這種解法適用于：

  • 初學者理解問題
  • 代碼簡潔性優先于空間效率的場景
  • 數組不太大的情況

4. 解法二：環狀替換法（原地算法）

4.1 思路

我們可以直接在原數組上進行操作，不使用額外空間。基本思想是：

  1. 從位置0開始，將當前位置的元素放到它應該去的位置（即(i + k) % n），同時記錄被替換的元素
  2. 然后將被替換的元素放到它應該去的位置，繼續這個過程
  3. 當我們回到起始位置時，我們已經完成了一個循環，需要從下一個位置開始新的循環
  4. 重復這個過程，直到所有元素都被訪問

這種方法不使用額外數組，但需要仔細處理訪問元素的順序。

4.2 Java代碼實現

class Solution {public void rotate(int[] nums, int k) {int n = nums.length;k = k % n;// 如果k為0，不需要輪轉if (k == 0) {return;}int count = 0; // 記錄已經移動的元素數量// 從0開始，最多需要處理n個元素for (int start = 0; count < n; start++) {int current = start; // 當前處理的位置int prev = nums[start]; // 當前位置的值do {// 計算下一個位置int next = (current + k) % n;// 保存下一個位置的值int temp = nums[next];// 將當前值放到下一個位置nums[next] = prev;// 更新current和prev，繼續下一次替換current = next;prev = temp;count++;} while (start != current); // 當回到起始位置時，一個循環結束}}
}

4.3 代碼詳解

環狀替換的關鍵在于追蹤元素的移動路徑，確保每個元素都被移動到正確位置：

int count = 0; // 記錄已經移動的元素數量// 從0開始，最多需要處理n個元素
for (int start = 0; count < n; start++) {int current = start; // 當前處理的位置int prev = nums[start]; // 當前位置的值
  • count變量記錄我們已經處理過的元素數量
  • start表示當前循環的起始位置
  • current跟蹤我們當前正在處理的位置
  • prev存儲當前位置原來的值
do {// 計算下一個位置int next = (current + k) % n;// 保存下一個位置的值int temp = nums[next];// 將當前值放到下一個位置nums[next] = prev;// 更新current和prev，繼續下一次替換current = next;prev = temp;count++;
} while (start != current); // 當回到起始位置時，一個循環結束
  • 計算元素應該被放置的下一個位置：(current + k) % n
  • 在替換前，保存目標位置的原始值
  • 將當前值放到目標位置
  • 更新current為新位置，prev為新位置原來的值
  • 增加已處理元素計數
  • 重復此過程，直到回到循環的起始位置

當一個循環結束（回到起始位置）時，可能還有未被訪問的元素。因此，我們增加start并開始一個新的循環，直到所有元素都被處理。

4.4 復雜度分析

  • 時間復雜度: O(n)，每個元素只會被移動一次，總共需要移動n次。
  • 空間復雜度: O(1)，只使用了有限的幾個變量，不需要額外數組。

4.5 陷阱與注意事項

環狀替換法需要特別注意：

  1. 處理循環長度：如果k和n有公約數，一個循環結束后可能還有元素未被訪問，需要開始新的循環
  2. 邊界條件：確保我們處理了所有的元素（通過計數）
  3. 避免原地自我覆蓋：在移動元素前保存下一個位置的值

5. 解法三：數組翻轉法（最優原地算法）

5.1 思路

這是最優雅且高效的解法。基本思想是：

  1. 首先翻轉整個數組
  2. 然后翻轉前k個元素
  3. 最后翻轉剩余的n-k個元素

這種方法不需要額外空間，操作簡單明了，且易于實現。

5.2 Java代碼實現

class Solution {public void rotate(int[] nums, int k) {int n = nums.length;k = k % n;// 如果k為0，不需要輪轉if (k == 0) {return;}// 1. 翻轉整個數組reverse(nums, 0, n - 1);// 2. 翻轉前k個元素reverse(nums, 0, k - 1);// 3. 翻轉剩余的n-k個元素reverse(nums, k, n - 1);}// 輔助函數：翻轉數組的指定部分private void reverse(int[] nums, int start, int end) {while (start < end) {int temp = nums[start];nums[start] = nums[end];nums[end] = temp;start++;end--;}}
}

5.3 代碼詳解

數組翻轉法的優雅之處在于它非常直觀：

// 1. 翻轉整個數組
reverse(nums, 0, n - 1);
  • 首先將整個數組翻轉，這樣原來的順序就變成了逆序
  • 例如：[1,2,3,4,5,6,7] 變成 [7,6,5,4,3,2,1]
// 2. 翻轉前k個元素
reverse(nums, 0, k - 1);
  • 然后翻轉前k個元素，將這部分恢復正確的相對順序
  • 對于k=3，[7,6,5,4,3,2,1] 的前k個元素 [7,6,5] 翻轉后變成 [5,6,7,4,3,2,1]
// 3. 翻轉剩余的n-k個元素
reverse(nums, k, n - 1);
  • 最后翻轉剩余的n-k個元素，將這部分也恢復正確的相對順序
  • [5,6,7,4,3,2,1] 的后n-k個元素 [4,3,2,1] 翻轉后變成 [5,6,7,1,2,3,4]
  • 這就是最終的輪轉結果
// 輔助函數：翻轉數組的指定部分
private void reverse(int[] nums, int start, int end) {while (start < end) {int temp = nums[start];nums[start] = nums[end];nums[end] = temp;start++;end--;}
}
  • 輔助函數實現了數組特定范圍內的翻轉
  • 使用雙指針法，從兩端向中間逐步交換元素
  • 這是一個標準的數組翻轉操作

5.4 數學證明

為什么數組翻轉法能實現輪轉效果？我們可以從數學角度證明：

設原數組為A，長度為n，需要右移k個位置。

  1. 定義A’ = A[0…n-k-1]，表示原數組的前n-k個元素
  2. 定義A’’ = A[n-k…n-1]，表示原數組的后k個元素
  3. 原數組可表示為：A = [A’, A’']
  4. 向右輪轉k個位置后的數組為：B = [A’‘, A’]

數組翻轉法的步驟：

  1. 翻轉整個數組：[A’, A’‘] → [(A’‘)^r, (A’)r]，其中r表示翻轉
  2. 翻轉前k個元素：[(A’‘)^r, (A’)^r] → [A’‘, (A’)^r]
  3. 翻轉后n-k個元素：[A’‘, (A’)^r] → [A’‘, A’]

最終結果：[A’‘, A’]，這正是輪轉后的結果。

5.5 復雜度分析

  • 時間復雜度: O(n)，翻轉數組需要O(n)的時間。
  • 空間復雜度: O(1)，只使用了有限的臨時變量。

5.6 適用場景

數組翻轉法因其簡潔性和效率，幾乎適用于所有場景：

  • 需要原地操作的場景
  • 性能要求高的場景
  • 代碼簡潔度要求高的場景

6. 詳細步驟分析與示例跟蹤

讓我們通過一個具體例子來跟蹤每種算法的執行過程，加深理解。

6.1 示例跟蹤：使用額外數組法

輸入：nums = [1,2,3,4,5,6,7], k = 3

  1. 計算實際輪轉次數：k = k % n = 3 % 7 = 3
  2. 創建新數組：result = new int[7]
  3. 將原數組元素放入新數組：
    • nums[0]=1 → result[(0+3)%7]=result[3]=1
    • nums[1]=2 → result[(1+3)%7]=result[4]=2
    • nums[2]=3 → result[(2+3)%7]=result[5]=3
    • nums[3]=4 → result[(3+3)%7]=result[6]=4
    • nums[4]=5 → result[(4+3)%7]=result[0]=5
    • nums[5]=6 → result[(5+3)%7]=result[1]=6
    • nums[6]=7 → result[(6+3)%7]=result[2]=7
  4. 現在result=[5,6,7,1,2,3,4]
  5. 將result復制回nums：nums=[5,6,7,1,2,3,4]

6.2 示例跟蹤：環狀替換法

輸入：nums = [1,2,3,4,5,6,7], k = 3

  1. 計算實際輪轉次數：k = k % n = 3 % 7 = 3

  2. 開始從start=0處的環狀替換：

    • 當前位置current=0，當前值prev=nums[0]=1
    • 下一個位置next=(0+3)%7=3，保存nums[3]=4
    • 將1放入位置3：nums=[1,2,3,1,5,6,7]，current=3，prev=4
    • 下一個位置next=(3+3)%7=6，保存nums[6]=7
    • 將4放入位置6：nums=[1,2,3,1,5,6,4]，current=6，prev=7
    • 下一個位置next=(6+3)%7=2，保存nums[2]=3
    • 將7放入位置2：nums=[1,2,7,1,5,6,4]，current=2，prev=3
    • 下一個位置next=(2+3)%7=5，保存nums[5]=6
    • 將3放入位置5：nums=[1,2,7,1,5,3,4]，current=5，prev=6
    • 下一個位置next=(5+3)%7=1，保存nums[1]=2
    • 將6放入位置1：nums=[1,6,7,1,5,3,4]，current=1，prev=2
    • 下一個位置next=(1+3)%7=4，保存nums[4]=5
    • 將2放入位置4：nums=[1,6,7,1,2,3,4]，current=4，prev=5
    • 下一個位置next=(4+3)%7=0，保存nums[0]=1
    • 將5放入位置0：nums=[5,6,7,1,2,3,4]，current=0，prev=1
    • 現在current=0=start，一個循環結束，且count=7，所有元素都已處理

  3. 最終結果：nums=[5,6,7,1,2,3,4]

6.3 示例跟蹤：數組翻轉法

輸入：nums = [1,2,3,4,5,6,7], k = 3

  1. 計算實際輪轉次數：k = k % n = 3 % 7 = 3
  2. 翻轉整個數組：
    • nums=[1,2,3,4,5,6,7] → nums=[7,6,5,4,3,2,1]
  3. 翻轉前k個元素（前3個）：
    • nums=[7,6,5,4,3,2,1] → nums=[5,6,7,4,3,2,1]
  4. 翻轉剩余n-k個元素（后4個）：
    • nums=[5,6,7,4,3,2,1] → nums=[5,6,7,1,2,3,4]
  5. 最終結果：nums=[5,6,7,1,2,3,4]

7. 常見錯誤與優化

7.1 常見錯誤

  1. 忘記處理k大于數組長度的情況：

    // 錯誤：不處理k大于數組長度的情況
public void rotate(int[] nums, int k) {// k可能大于nums.length，未處理會導致索引越界...
}// 正確：進行取模操作
public void rotate(int[] nums, int k) {int n = nums.length;k = k % n; // 確保k在有效范圍內...
}

  2. 環狀替換中的循環處理錯誤：

    // 錯誤：處理不完整，可能漏掉某些元素
public void rotate(int[] nums, int k) {// ...int start = 0;int current = start;int prev = nums[start];// 只進行一個循環，可能無法處理所有元素do {// ...} while (start != current);
}// 正確：確保處理所有元素
public void rotate(int[] nums, int k) {// ...int count = 0;for (int start = 0; count < n; start++) {// 確保所有元素都被處理// ...count++;}
}

  3. 數組翻轉邊界錯誤：

    // 錯誤：翻轉邊界不正確
reverse(nums, 0, k); // 錯誤，應該是k-1
reverse(nums, k, n); // 錯誤，應該是k到n-1// 正確：正確的翻轉邊界
reverse(nums, 0, k - 1);
reverse(nums, k, n - 1);

7.2 優化技巧

  1. 提前檢查特殊情況：

    // 優化：提前處理不需要輪轉的情況
if (k == 0 || k % n == 0) {return; // 不需要輪轉
}

  2. 使用Java內置的數組復制方法：

    // 優化：使用System.arraycopy替代手動循環復制
System.arraycopy(result, 0, nums, 0, n);

  3. 減少不必要的取模操作：

    // 優化前：每次都進行取模
for (int i = 0; i < n; i++) {result[(i + k) % n] = nums[i];
}// 優化后：預計算起始位置
int start = n - k;
for (int i = 0; i < k; i++) {result[i] = nums[start + i];
}
for (int i = 0; i < n - k; i++) {result[k + i] = nums[i];
}

  4. 環狀替換中優化循環判斷：

    // 優化：使用數學方法計算循環次數
int gcd = gcd(n, k); // 計算n和k的最大公約數// 只需要進行gcd次循環，每次處理n/gcd個元素
for (int start = 0; start < gcd; start++) {// ...
}// 輔助方法：計算最大公約數
private int gcd(int a, int b) {return b == 0 ? a : gcd(b, a % b);
}

8. 三種解法的對比與選擇

解法時間復雜度空間復雜度優點缺點適用場景
額外數組法O(n)O(n)簡單直觀，容易實現需要額外空間初學者，空間不敏感的場景
環狀替換法O(n)O(1)不需要額外空間實現較復雜，需要處理循環空間敏感場景，追求原地操作
數組翻轉法O(n)O(1)優雅簡潔，不需要額外空間需要理解翻轉原理幾乎所有場景的最優選擇

總結：

  • 如果你是初學者或追求代碼簡潔性，使用額外數組法
  • 如果你需要節省空間且追求性能，使用數組翻轉法
  • 環狀替換法雖然有趣，但實現復雜，通常不是首選

9. 擴展題目與應用

9.1. 左輪轉數組

與本題類似，但方向相反，將數組元素向左移動k個位置。

解決方案：

  • 向左輪轉k個位置等同于向右輪轉n-k個位置
  • 或者使用相同的數組翻轉法，只需調整翻轉順序：
    1. 翻轉整個數組
    2. 翻轉前n-k個元素
    3. 翻轉后k個元素

9.2. 字符串輪轉

LeetCode 796. 旋轉字符串：檢查一個字符串是否可以通過多次輪轉變成另一個字符串。

解決思路：將原字符串與自身拼接，如果目標字符串是拼接結果的子串，則可以通過輪轉得到。

9.3. 循環移位操作

在計算機系統中，輪轉操作常用于循環移位（Circular Shift）：

  • 循環左移：將二進制數的最高位移到最低位
  • 循環右移：將二進制數的最低位移到最高位

10. 實際應用場景

輪轉數組在實際編程中有多種應用：

  1. 緩沖區管理：

    • 實現循環緩沖區時，可以使用輪轉數組避免數據移動
    • 在流媒體處理中保持最近的數據片段

  2. 圖像處理：

    • 圖像旋轉和變換
    • 圖像濾波器的實現

  3. 信號處理：

    • 信號采樣和處理時的數據輪轉
    • FFT算法中的數據重排

  4. 游戲開發：

    • 游戲地圖的循環移動（如無限地圖）
    • 輪流游戲中的玩家順序管理

  5. 調度算法：

    • 輪轉調度算法（Round Robin）中任務的輪換
    • 分時系統中的時間片分配

11. 完整的 Java 解決方案

以下是結合了各種最佳實踐的最優解法（數組翻轉法）：

class Solution {public void rotate(int[] nums, int k) {if (nums == null || nums.length <= 1) {return; // 處理邊界情況}int n = nums.length;k = k % n; // 處理k大于數組長度的情況if (k == 0) {return; // 不需要輪轉}// 三步翻轉法reverse(nums, 0, n - 1);   // 翻轉整個數組reverse(nums, 0, k - 1);   // 翻轉前k個元素reverse(nums, k, n - 1);   // 翻轉剩余的n-k個元素}// 翻轉數組的指定范圍private void reverse(int[] nums, int start, int end) {while (start < end) {int temp = nums[start];nums[start++] = nums[end];nums[end--] = temp;}}
}

這個解法簡潔高效，適用于大多數場景。在LeetCode上，這個解法通常能擊敗95%以上的提交。

12. 總結與技巧

12.1 解題要點

  1. 正確理解輪轉：理解輪轉的本質是循環移動，超出數組末尾的元素會回到開頭。
  2. 取模處理：使用k % n來處理k可能大于數組長度的情況。
  3. 選擇合適的算法：根據空間要求選擇適當的算法（額外空間法或原地算法）。
  4. 翻轉技巧：數組翻轉是解決輪轉問題的強大工具。

12.2 學習收獲

通過學習輪轉數組問題，你可以掌握：

  • 原地算法的思想和實現
  • 雙指針技術在數組操作中的應用
  • 數學思維在算法設計中的重要性
  • 空間和時間復雜度的權衡

12.3 面試技巧

如果在面試中遇到此類問題：

  1. 先提出最簡單的解法（使用額外數組）
  2. 然后提出原地算法（如數組翻轉法）
  3. 討論每種方法的時間和空間復雜度
  4. 分析各種解法的適用場景和優缺點
  5. 實現你認為最優的解法

記住，展示你的思考過程和對不同解法的理解，比僅僅給出一個正確答案更重要。

13. 參考資料

  • LeetCode 官方題解：輪轉數組
  • LeetCode 題目鏈接：輪轉數組

本文來自互聯網用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務，不擁有所有權，不承擔相關法律責任。
如若轉載，請注明出處：http://www.pswp.cn/pingmian/80649.shtml
繁體地址，請注明出處：http://hk.pswp.cn/pingmian/80649.shtml
英文地址，請注明出處：http://en.pswp.cn/pingmian/80649.shtml

如若內容造成侵權/違法違規/事實不符，請聯系多彩編程網進行投訴反饋email:809451989@qq.com，一經查實，立即刪除！

相關文章

數據治理域——日志數據采集設計

數據治理域——日志數據采集設計

摘要 本文主要介紹了Web頁面端日志采集的設計。首先闡述了頁面瀏覽日志采集&#xff0c;包括客戶端日志采集的實現方式、采集內容及技術亮點。接著介紹了無線客戶端端日志采集&#xff0c;包括UserTrack的核心設計、移動端與瀏覽器端采集差異以及典型應用場景崩潰分析。最后探…
閱讀更多...
PYTHON訓練營DAY24

PYTHON訓練營DAY24

# SO代碼我們的感情好像跳樓機 # 元組創建時&#xff0c;可以省略括號&#xff1a;my_tuple4 10, 20, thirty # 字符串要加“ ” 元組 一、創建 my_tuple1 (1, 2, 3) my_tuple2 (a, b, c) my_tuple3 (1, hello, 3.14, [4, 5]) # 可以包含不同類型的元素 print(my_tupl…
閱讀更多...
超聲波傳感器模塊

超聲波傳感器模塊

歡迎來到 破曉的歷程的 博客 ??不負時光&#xff0c;不負己?? 文章目錄 1.HC-SR04介紹2.HC-SR04原理介紹2.1原理概述3.2原理詳解 4驅動代碼編寫4.1寫前思考4.2硬件連線 5.總結hcsr04.hhcsr04.c 1.HC-SR04介紹 超聲波傳感器有很多種類的型號&#xff1a;HC-SR04、UC-025、…
閱讀更多...
《Effective Python》第2章 字符串和切片操作——深入理解Python 中的字符數據類型（bytes 與 str）的差異

《Effective Python》第2章 字符串和切片操作——深入理解Python 中的字符數據類型（bytes 與 str）的差異

引言 本篇博客基于學習《Effective Python》第三版 Chapter 2: Strings and Slicing 中的 Item 10: Know the Differences Between bytes and str 的總結與延伸。在 Python 編程中&#xff0c;字符串處理是幾乎每個開發者都會頻繁接觸的基礎操作。然而&#xff0c;Python 中的…
閱讀更多...
py7zr解壓文件時報錯CrcError(crc32, f.crc32, f.filename)

py7zr解壓文件時報錯CrcError(crc32, f.crc32, f.filename)

報錯信息 Traceback (most recent call last):File "/home/hp/project/test/file_util.py", line 130, in extract_archive_7zarchive.extract(targets[fixed_file], pathoutput_dir, recursiveTrue)File "/home/hp/miniconda3/envs/celery/lib/python3.10/sit…
閱讀更多...
物理：由基本粒子組成的個體能否提煉和重組？

物理：由基本粒子組成的個體能否提煉和重組？

個體差異源于基本粒子組合的復雜性與隨機性，這一假設若成立，確實可能為生物醫學帶來革命性突破——但需要突破技術、理論與系統層級的多重壁壘。以下從科學邏輯與技術路徑展開分析： 一、隨機組合中的共性與穩定結構 1. 自然界的自組織規律 涌現性（Emergence）：盡管粒子組…
閱讀更多...
動態路由EIGRP的配置

動態路由EIGRP的配置

動態路由EIGRP的配置 動態路由EIGRP&#xff1a;增強內部網關協議 為何收斂快、不成環&#xff1f; 路由計算的無環路和路由的收斂速度是路由計算的重要指標。EIGRP協議由于使用了DUAL算法&#xff0c;使得EIGRP協議在路由計算中不可能有環路路由產生&#xff0c;同時路由計…
閱讀更多...
組合問題（多條件）

組合問題（多條件）

39. 組合總和 - 力扣&#xff08;LeetCode&#xff09; class Solution { private:vector<vector<int>>result;vector<int>path;void backtracking(vector<int>& candidates, int target,int sum,int startIndex){if(sum>target){return;}if(…
閱讀更多...
SimScape物理建模實例2--帶控制的單質量彈簧阻尼系統

SimScape物理建模實例2--帶控制的單質量彈簧阻尼系統

模型下載&#xff1a; 基于simscape&#xff0c;單質量系統帶位置控制資源-CSDN文庫 在實例1中&#xff0c;我們搭建了不帶控制的單質量彈簧阻尼系統&#xff0c;該系統沒有外界力量介入&#xff0c;只有彈簧的初始彈力&#xff0c;帶著彈簧使勁彈來彈去。 SimScape物理建模實…
閱讀更多...
OpenAI Text 模型與 Chat 模型調用實戰指南：從基礎配置到創意花店命名

OpenAI Text 模型與 Chat 模型調用實戰指南：從基礎配置到創意花店命名

在 AI 應用開發的浪潮中&#xff0c;OpenAI 的大語言模型成為開發者實現創新功能的得力工具。其中&#xff0c;Text 模型和 Chat 模型作為核心接口&#xff0c;被廣泛應用于文本生成、對話交互等場景。本文將以 “為花店起名” 為實際需求&#xff0c;手把手教你如何安全調用這…
閱讀更多...
網頁常見水印實現方式

網頁常見水印實現方式

文章目錄 1 明水印技術實現1.1 DOM覆蓋方案1.2 Canvas動態渲染1.3 CSS偽元素方案2 暗水印技術解析2.1 空域LSB算法2.2 頻域傅里葉變換3 防篡改機制設計3.1 MutationObserver防護3.2 Canvas指紋追蹤4 前后端實現對比5 攻防博弈深度分析5.1 常見破解手段5.2 進階防御策略6 選型近…
閱讀更多...
現代化QML組件開發教程

現代化QML組件開發教程

現代化QML組件開發教程 目錄 QML基礎介紹QML項目結構基本組件詳解自定義組件開發狀態與過渡高級主題最佳實踐 QML基礎介紹 什么是QML QML (Qt Meta Language) 是一種聲明式語言&#xff0c;專為用戶界面設計而創建。它是Qt框架的一部分&#xff0c;讓開發者能夠創建流暢、…
閱讀更多...
C/C++ 程序執行的主要過程

C/C++ 程序執行的主要過程

預處理&#xff08;Preprocessing&#xff09; 任務&#xff1a; 處理源代碼中以 # 開頭的預處理指令&#xff0c;包括&#xff1a; 頭文件包含&#xff08;#include&#xff09;&#xff1a;將頭文件&#xff08;如 stdio.h&#xff09;的內容直接插入到源文件中。宏替換&…
閱讀更多...
時間序列預測建模的完整流程以及數據分析【學習記錄】

時間序列預測建模的完整流程以及數據分析【學習記錄】

文章目錄 1.時間序列建模的完整流程2. 模型選取的和數據集2.1.ARIMA模型2.2.數據集介紹 3.時間序列建模3.1.數據獲取3.2.處理數據中的異常值3.2.1.Nan值3.2.2.異常值的檢測和處理&#xff08;Z-Score方法&#xff09; 3.3.離散度3.4.Z-Score3.4.1.概述3.4.2.公式3.4.3.Z-Score與…
閱讀更多...
ValueError: Caught ValueError in DataLoader worker process 0.

ValueError: Caught ValueError in DataLoader worker process 0.

參考鏈接&#xff1a; https://stackoverflow.com/questions/1841565/valueerror-invalid-literal-for-int-with-base-10 它提示我有個地方值錯誤空字符 果然因為格式處理沒有傳進去東西&#xff0c;找下原因&#xff0c;讓它正常處理 原來是相對路徑的.影響了程序運行 將v…
閱讀更多...
JavaScript性能優化實戰,從理論到落地的全面指南

JavaScript性能優化實戰,從理論到落地的全面指南

在前端開發領域&#xff0c;JavaScript的性能優化是提升用戶體驗的核心環節。隨著Web應用復雜度的提升&#xff0c;開發者面臨的性能瓶頸也日益多樣化。本文將從理論分析、代碼實踐和工具使用三個維度&#xff0c;系統性地講解JavaScript性能優化的實戰技巧&#xff0c;并通過大…
閱讀更多...
SQL、Oracle 和 SQL Server 的比較與分析

SQL、Oracle 和 SQL Server 的比較與分析

SQL、Oracle 和 SQL Server 的比較與分析 一、基礎概念 1. SQL (Structured Query Language) 定義&#xff1a;結構化查詢語言&#xff0c;用于管理關系型數據庫的標準語言類型&#xff1a; DDL (數據定義語言)&#xff1a;CREATE, ALTER, DROPDML (數據操作語言)&#xff1…
閱讀更多...
Telnet 類圖解析

Telnet 類圖解析

Telnet 類圖&#xff08;文本描述&#xff09; --------------------------------------- | Telnet | --------------------------------------- | - host: str | # 目標主機 | - port: int …
閱讀更多...
Ansible安裝與核心模塊實戰指南

Ansible安裝與核心模塊實戰指南

Ansible安裝與核心模塊實戰指南 自動化運維入門：從安裝到模塊化任務配置 Ansible作為一款無代理自動化工具，通過模塊化設計實現高效管理，尤其適用于快速部署、配置和維護大規模系統。本文將從安裝、核心模塊使用到實際案例，全面解析其核心功能與最佳實踐。 一、Ansible安裝…
閱讀更多...
VLLM推理大模型顯存不夠后，導致程序引擎崩潰的調優方案嘗試

VLLM推理大模型顯存不夠后，導致程序引擎崩潰的調優方案嘗試

背景介紹 硬件 A800 80G模型 chat-glm4-9b-128K環境 生產正常顯存占用情況 glm4 占用32GB 其他顯存工占用38GB左右 總共剩余10GB。 問題描述 推理時報錯日志&#xff0c;由于內網環境無法拿出日志&#xff0c;與下面的類似。 File "/data/miniconda3_new/envs/vllm-new…
閱讀更多...
最新文章

Copyright @ 2022~2023