| English | 释义 | 拼音 |
|---|---|---|
| shift/ʃɪft/ | 移位 | yí wèi |
| delete/dɪˈliːt/ | 删除 | shān chú |
| insert/ˈɪnsɜːt/ | 插入 | chā rù |
Adjacent removals reveal a skipped element
- Starting with
[0, 0, 5], remove index 0 and then increment i. The second zero has shifted into index 0, so that forward loop skips it and leaves[0, 5]. - For the forward while-loop taught here, stay at the same index after removal and advance only when keeping an element. It then removes both zeros and finishes with
[5].
![Adjacent removals reveal the skipped-element bug: scanning [0, 0, 5] forwards, removing index 0 and then incrementing skips the second zero, which moved to index 0; keep the same index after a removal and increment only when keeping an item, giving [5]](/learn-media/ap_computer_science_a/assets/0410-skip-bug.png?v=1794647927)
Keep the current forward index after removal
- After
remove(i), every later element shifts one place left. If an element now occupies i, it has not yet been checked; inspect it on the next iteration. - The loop below accepts a non-null list of non-null Integers and removes every zero in place. It uses current size each iteration and performs no get call on an empty list.
import java.util.ArrayList;
public class RemoveZeros {
public static void removeZeros(ArrayList<Integer> list) {
int i = 0;
while (i < list.size()) {
if (list.get(i) == 0) {
list.remove(i);
} else {
i++;
}
}
}
}
Explain why this loop terminates
- Each iteration either removes one element and reduces size, or keeps one and increases i. Thus
size() - i, the number of positions still to check, decreases by one each iteration. - Starting with
[0, 0, 5], the states are[0, 5]at i=0,[5]at i=0, then[5]at i=1. The final condition is false, so no out-of-bounds access occurs.
A backward loop follows a different rule
- A reverse loop starts at the final existing index:
for (int i = list.size() - 1; i >= 0; i--). Remove matching elements withremove(i); the next i is always one lower. - Deleting at i shifts only later indices, which have already been checked. Earlier unchecked elements retain their indices, so decrementing after a removal is correct here; “never advance after removal” is not a universal rule.
Choose an index update that matches the direction of traversal. In the forward while-loop, stay after removal; in the backward for-loop, continue decrementing. Direct structural changes during an enhanced loop are a separate unsafe pattern, even when no fail-fast exception appears.
在此所示的正向while循环中,仅在您...时才递增i。
难度 1/5 · 今日首次完成可获 100 金币及少量额外奖励
remove(i) 之后,下一个元素会移动到索引 i ——不要跳过它。
在[0, 0, 5]上的朴素正向循环在i=0处执行删除后随即递增i,从而跳过了下一个零。
难度 1/5 · 今日首次完成可获 100 金币及少量额外奖励
剩余的零移至索引0,但下一次测试位于索引1。反向循环使用不同的正确索引规则。
避免位移的原地移除替代方案是...
难度 1/5 · 今日首次完成可获 100 金币及少量额外奖励
将保留项添加到新列表中可避免位移。
ArrayList 算法通过...复用了数组模式:
难度 1/5 · 今日首次完成可获 100 金币及少量额外奖励
用 get(i) 和 size() 替换数组 [] 和 length。
ArrayList 的可变长度特性允许插入和删除元素,而固定数组不行。
难度 1/5 · 今日首次完成可获 100 金币及少量额外奖励
添加 和 remove 改变列表大小。
从size()-1开始的反向删除循环必须在每次删除后停留在同一索引位置。
难度 1/5 · 今日首次完成可获 100 金币及少量额外奖励
错误:先前未被检查的元素保留其原有索引,因此反向循环正常递减。
Build a new list when the original must remain
- To preserve the original list, create a fresh result and append every nonzero element while reading the original. This keeps the original sequence and its size unchanged; it uses additional list storage.
- For lists of mutable objects, copying retained references does not clone those objects. A new list structure may still share its element objects with the original; distinguish list identity from element identity.
正向删除后,索引保留在删除位置的下一个位置。
在索引0处检查两个相邻零之前,先保留5。
Check the cases that expose the algorithm
- Test an empty list, all zeros, no zeros, adjacent zeros and a zero at the last index. For in-place removal, other references to the same list observe its change; a fresh result leaves that original structure intact.
- An ArrayList can insert 插入 or delete 删除 elements; those operations can shift 移位 later indices. A search may return a found index or -1 when absent; a maximum requires an explicit empty-list policy. Reusing array patterns through get/size helps, but each algorithm still needs its own bounds and contract.
Removing shifts indices. Explain which elements remain unchecked and choose the next index accordingly. Forward stay-or-increment and backward decrement are both valid patterns; a fresh list of keepers preserves the original structure but may share objects.
Order the states for the corrected removal loop on [0, 0, 5].
难度 3/5 · 今日首次完成可获 200 金币及少量额外奖励
Each removal rechecks the shifted value; keeping 5 finally advances the index.
所示的正向removeZeros方法在空列表上执行了多少次get调用?
难度 2/5 · 今日首次完成可获 140 金币及少量额外奖励
初始条件0 < 0为假,因此未发生任何get调用。