Java自定义链表：在指定索引处插入元素的正确实现

import java.util.NoSuchElementException;

// 假设 CellList 类结构如下：
public class CellList {

    public class cellNode {
        private cellPhone phone;
        private cellNode next;
        // ... 构造器、getter、setter 等省略
    }

    private cellNode head;
    private int size;
    // ... 构造器、addToStart 等省略

    public void insertAtIndex(cellPhone c, int index) {
        if(index < 0 || index >= size) { // 注意这里的边界条件判断
            throw new NoSuchElementException("Out of boundary!!!");
        }
        else {
            if(index == 0) {
                addToStart(c); // 在头部插入
            }
            else { // 处理 index > 0 且 index < size 的情况
                cellNode curr = head.next;
                cellNode prev = head;
                // 注意：这里的 cn.next 被错误地初始化为 head，应该在找到位置后再设置
                cellNode cn = new cellNode(c, head); 
                int i = 1;
                while(curr != null) { // 循环条件应是 i < index
                    if(i == index) {
                        prev.next = cn;
                        cn.next = curr;
                        size++;
                        // i++; // 缺失的关键行，导致逻辑错误
                        return;
                    }
                    prev = curr;
                    curr = curr.next;
                    // i++; // 缺失的关键行，应该在此处递增
                }
            }
        }
    }
}

import java.util.NoSuchElementException; // 确保导入此异常类

// 假设 CellList 和 cellNode 类已按标准方式定义，
// 包含 head, size, addToStart 等基本成员和方法。
public class CellList {

    public class cellNode {
        private cellPhone phone;
        private cellNode next;

        public cellNode() {
            this.phone = null;
            this.next = null;
        }

        public cellNode(cellPhone phone, cellNode next) {
            this.phone = phone;
            this.next = next;
        }
        // ... 其他构造器、getter、setter 等省略
    }

    private cellNode head;
    private int size;

    public CellList() {
        this.head = null;
        this.size = 0;
    }

    public void addToStart(cellPhone c) {
        cellNode newNode = new cellNode(c, head);
        head = newNode;
        size++;
    }

    /**
     * 在链表的指定索引处插入一个新元素。
     *
     * @param c 要插入的 cellPhone 对象。
     * @param index 插入位置的索引。
     * @throws NoSuchElementException 如果索引越界。
     */
    public void insertAtIndex(cellPhone c, int index) {
        // 1. 边界条件检查：索引是否有效
        // 允许在 index == size 处插入（即在链表末尾），但 index < 0 或 index > size 则为越界。
        if (index < 0 || index > size) {
            throw new NoSuchElementException("Index " + index + " is out of bounds for list size " + size + ".");
        }

        // 2. 特殊情况：在链表头部插入 (index == 0)
        // 可以复用已有的 addToStart 方法，提高代码复用性。
        if (index == 0) {
            addToStart(c);
            return;
        }

        // 3. 一般情况：在链表中间或末尾插入 (index > 0)
        // 需要找到目标位置的前一个节点 (即 index - 1 处的节点)。
        cellNode current = head;
        // 遍历到 index - 1 处，这样 current 就是新节点的前驱。
        for (int i = 0; i < index - 1; i++) {
            current = current.next;
        }

        // current 现在是 index-1 位置的节点。
        // 创建新节点，并将其 next 指向 current 原来的下一个节点。
        cellNode newNode = new cellNode(c, current.next);
        // 将 current 的 next 指针更新为指向新节点。
        current.next = newNode;
        size++; // 链表大小增加
    }

    // 假设还有其他方法如 displayList, contains, deleteFromIndex 等
    // 为了测试，可以添加一个简单的打印方法
    public void displayList() {
        cellNode temp = head;
        System.out.print("List: ");
        while (temp != null) {
            System.out.print(temp.phone + " -> ");
            temp = temp.next;
        }
        System.out.println("null (Size: " + size + ")");
    }

    // 假设 cellPhone 类有一个 toString 方法
    static class cellPhone {
        String model;
        public cellPhone(String model) { this.model = model; }
        @Override public String toString() { return model; }
    }

    public static void main(String[] args) {
        CellList list = new CellList();
        list.addToStart(new cellPhone("Phone A")); // Index 0
        list.addToStart(new cellPhone("Phone B")); // Index 0 (old A becomes Index 1)
        list.addToStart(new cellPhone("Phone C")); // Index 0 (old B becomes Index 1, A becomes Index 2)
        list.displayList(); // Expected: C -> B -> A -> null (Size: 3)

        System.out.println("\nInserting 'Phone D' at index 1:");
        list.insertAtIndex(new cellPhone("Phone D"), 1);
        list.displayList(); // Expected: C -> D -> B -> A -> null (Size: 4)

        System.out.println("\nInserting 'Phone E' at index 0:");
        list.insertAtIndex(new cellPhone("Phone E"), 0);
        list.displayList(); // Expected: E -> C -> D -> B -> A -> null (Size: 5)

        System.out.println("\nInserting 'Phone F' at index 5 (end):");
        list.insertAtIndex(new cellPhone("Phone F"), 5);
        list.displayList(); // Expected: E -> C -> D -> B -> A -> F -> null (Size: 6)

        System.out.println("\nInserting 'Phone G' at index 3:");
        list.insertAtIndex(new cellPhone("Phone G"), 3);
        list.displayList(); // Expected: E -> C -> D -> G -> B -> A -> F -> null (Size: 7)

        System.out.println("\nAttempting to insert at invalid index 8:");
        try {
            list.insertAtIndex(new cellPhone("Phone H"), 8);
        } catch (NoSuchElementException e) {
            System.out.println(e.getMessage()); // Expected: Index 8 is out of bounds for list size 7.
        }
    }
}