Java中如何创建并遍历链表数组？现有单链表代码修改咨询

当然可以改造现有代码来实现链表数组！咱们直接从需求出发，一步步调整代码，实现创建、插入、遍历整个锯齿数组的功能。

核心修改点 #

• 创建链表数组容器：用LinkedList1[]类型的数组来存储多个独立的单链表实例，每个数组元素对应一个链表的头节点（也就是LinkedList1对象的head属性）。
• 复用原有单链表功能：原有的Node类、sortedInsert有序插入方法、newNode节点创建方法、printList单链表打印方法完全可以复用，因为每个数组元素都是独立的LinkedList1对象，各自维护自己的链表结构。
• 添加数组遍历逻辑：新增遍历数组的代码，逐个调用每个链表的printList方法，实现整个锯齿数组的内容打印。

修改后的完整代码 #

// Java Program to implement a Jagged Array of sorted Linked Lists
class LinkedList1 {
    Node head; // head of individual list

    /* Linked list Node*/
    class Node {
        int s;
        int a;
        Node next;

        Node(int starting_time, int arrival_time) {
            s = starting_time;
            a = arrival_time;
            next = null;
        }
    }

    /* function to insert a new_node in a sorted list. */
    void sortedInsert(Node new_node) {
        Node current;
        /* Special case for head node */
        if (head == null || head.a >= new_node.a) {
            new_node.next = head;
            head = new_node;
        } else {
            /* Locate the node before point of insertion. */
            current = head;
            while (current.next != null && current.next.a < new_node.a)
                current = current.next;
            new_node.next = current.next;
            current.next = new_node;
        }
    }

    /*Utility functions*/
    /* Function to create a node */
    Node newNode(int s, int a) {
        Node x = new Node(s, a);
        return x;
    }

    /* Function to print single linked list */
    void printList() {
        Node temp = head;
        if (temp == null) {
            System.out.print("Empty List");
            return;
        }
        while (temp != null) {
            System.out.print("[" + temp.s + "," + temp.a + "] ");
            temp = temp.next;
        }
    }

    /* Driver function to test above methods */
    public static void main(String args[]) {
        // 1. 创建链表数组，长度为3（可根据需求调整）
        int arraySize = 3;
        LinkedList1[] jaggedArray = new LinkedList1[arraySize];

        // 2. 初始化数组中的每个链表实例
        for (int i = 0; i < arraySize; i++) {
            jaggedArray[i] = new LinkedList1();
        }

        // 3. 给第一个链表插入节点
        jaggedArray[0].sortedInsert(jaggedArray[0].newNode(5, 6));
        jaggedArray[0].sortedInsert(jaggedArray[0].newNode(10, 2));

        // 4. 给第二个链表插入节点
        jaggedArray[1].sortedInsert(jaggedArray[1].newNode(7, 3));
        jaggedArray[1].sortedInsert(jaggedArray[1].newNode(3, 4));

        // 5. 给第三个链表插入节点
        jaggedArray[2].sortedInsert(jaggedArray[2].newNode(1, 5));
        jaggedArray[2].sortedInsert(jaggedArray[2].newNode(9, 1));

        // 6. 遍历整个链表数组并打印
        System.out.println("Created Jagged Array of Linked Lists:");
        for (int i = 0; i < arraySize; i++) {
            System.out.print("List [" + i + "]: ");
            jaggedArray[i].printList();
            System.out.println();
        }
    }
}

代码说明 #

• 链表数组初始化：通过LinkedList1[] jaggedArray = new LinkedList1[arraySize];创建数组，然后循环给每个位置初始化新的LinkedList1对象，确保每个链表都是独立的。
• 独立插入操作：每个链表调用自己的sortedInsert方法，因为它们的head属性是各自独立的，不会互相干扰。
• 遍历打印：循环数组的每个索引，调用对应链表的printList方法，同时标注链表的索引，清晰展示锯齿数组的结构。

内容的提问来源于stack exchange，提问作者Akash Ghosh