用Java创建链表出错

陈落轩

public class Test1 {
    public static void main ( String [] args) {
            Test1 test1 = new Test1(); //创建一个Test1对象
            MyList myList = test1.new MyList(); //用Test1对象来创建MyList对象
            Node node1 = myList.new Node(10); //用MyList对象来创建Node对象
            Node node2 = myList.new Node(4);
            Node node3 = myList.new Node(15);
            Node node4 = myList.new Node(20);
            Node node5 = myList.new Node(22);
            myList.add(node1); //将结点添加到链表中
            myList.add(node2);
            myList.add(node3);
            myList.add(node4);
            myList.add(node5);
            myList.display(); //显示链表中的所有数据
            myList.remove(2); //删除第三个结点
            myList.display(); //显示删除后的链表
            System.out.println(myList.getAt(1).data); //打印第二个结点的数据
    }
  
  class MyList{ //定义为非静态的内部类
      private Node firstNode; //链表的头结点
      private int length; //链表的长度
    
      public MyList(){ //构造方法，初始化一个空链表
              firstNode = null;
              length = 0;
      }
    
      public void clear(){ //清空链表
              firstNode = null;
              length = 0;
      }
    
      public void add(Node d){ //在链表尾部添加一个结点
              if(firstNode == null){ //如果链表为空，直接将新结点作为头结点
                  firstNode = d;
              }else{ //否则，遍历链表，找到最后一个结点，将新结点链接到它后面
                  Node current = firstNode;
                  while(current.next != null){
                          current = current.next;
                  }
                  current.next = d;
              }
              length++; //链表长度加一
      }
    
    public void remove(int i){ //删除指定位置的结点
        if(i < 0 || i >= length){ //如果位置不合法，抛出异常
                throw new IndexOutOfBoundsException("Invalid index: " + i);
        }else if(i == 0){ //如果位置为0，直接将头结点指向下一个结点
                firstNode = firstNode.next;
        }else{ //否则，遍历链表，找到要删除的结点的前一个结点，将它的next指向要删除的结点的next
                Node previous = firstNode;
        for(int j = 0; j < i - 1; j++){
            previous = previous.next;
        }
        Node current = previous.next;
        previous.next = current.next;
        }
        length--; //链表长度减一
    }
    
    public Node getAt(int i){ //获取指定位置的结点
        if(i < 0 || i >= length){ //如果位置不合法，抛出异常
                throw new IndexOutOfBoundsException("Invalid index: " + i);
        }else{ //否则，遍历链表，找到要返回的结点，并返回它
                Node current = firstNode;
        for(int j = 0; j < i; j++){
            current = current.next;
        }
          return current;
        }
    }
    
    public void display(){ //显示链表中的所有数据
        Node current = firstNode;
        while(current != null){
                System.out.print(current.data + " ");
        current = current.next;
        }
        System.out.println();
    }
  

        class Node { //定义为非静态的内部类
                 private int data; //结点存储的数据
                 private Node next; //结点指向的下一个结点
                    
                 private Node(int d){ //构造方法，初始化一个只有数据的结点
              data = d; 
              next = null;
            }
                    
            private Node(int d, Node n){ //构造方法，初始化一个有数据和下一个结点的结点
              data = d; 
              next = n;
            }
          }
        }
}

如图，在使用Java创建链表时出现如下错误，请问该怎么办呐

isdkz

这个错误是因为在创建链表时，没有正确地引用内部类Node。在Java中，内部类的实例化需要使用外部类的实例来创建。在这个例子中，你需要使用MyList类的实例来创建Node类的实例。

解决这个问题的方法是，在创建Node对象时，使用正确的语法来引用内部类。修改代码如下：

Node node1 = test1.myList.new Node(10);
Node node2 = test1.myList.new Node(4);
Node node3 = test1.myList.new Node(15);
Node node4 = test1.myList.new Node(20);
Node node5 = test1.myList.new Node(22);

通过这样的修改，你就能够正确地创建链表并运行代码了。

Mike_python小

问题分析：

从错误信息中可以看到，报错是在创建Node对象时发生的。具体错误信息为：

[/code]
1 - 非静态变量不能在静态上下文中引用
2 - The constructor Test1.MyList.Node(int) is undefined
[/code]

根据错误信息，我们可以得出两个问题：

1. 在静态方法（main方法）中，无法引用非静态内部类（MyList类）的成员（Node类构造方法）。
2. 缺少Node类的构造方法。

问题解决：

为了解决第一个问题，我们需要将静态方法中的MyList类声明为静态内部类。修改方式如下：

[/code]java
static class MyList {
    // ...
}
[/code]

为了解决第二个问题，我们需要为Node类提供构造方法。修改方式如下：

[/code]java
class Node {
    // ...

    public Node(int d) {
        data = d;
        next = null;
    }
}
[/code]

经过以上修改，代码应该能正确执行。

完整修改后的代码如下：

[/code]java
public class Test1 {
    public static void main(String[] args) {
        Test1 test1 = new Test1(); // 创建一个Test1对象
        MyList myList = new MyList(); // 用Test1对象来创建MyList对象
        Node node1 = myList.new Node(10); // 用MyList对象来创建Node对象
        Node node2 = myList.new Node(4);
        Node node3 = myList.new Node(15);
        Node node4 = myList.new Node(20);
        Node node5 = myList.new Node(22);
        myList.add(node1); // 将结点添加到链表中
        myList.add(node2);
        myList.add(node3);
        myList.add(node4);
        myList.add(node5);
        myList.display(); // 显示链表中的所有数据
        myList.remove(2); // 删除第三个结点
        myList.display(); // 显示删除后的链表
        System.out.println(myList.getAt(1).data); // 打印第二个结点的数据
    }

    static class MyList { // 将MyList类声明为静态内部类
        private Node firstNode; // 链表的头结点
        private int length; // 链表的长度

        public MyList() { // 构造方法，初始化一个空链表
            firstNode = null;
            length = 0;
        }

        public void clear() { // 清空链表
            firstNode = null;
            length = 0;
        }

        public void add(Node d) { // 在链表尾部添加一个结点
            if (firstNode == null) { // 如果链表为空，直接将新结点作为头结点
                firstNode = d;
            } else { // 否则，遍历链表，找到最后一个结点，将新结点链接到它后面
                Node current = firstNode;
                while (current.next != null) {
                    current = current.next;
                }
                current.next = d;
            }
            length++; // 链表长度加一
        }

        public void remove(int i) { // 删除指定位置的结点
            if (i < 0 || i >= length) { // 如果位置不合法，抛出异常
                throw new IndexOutOfBoundsException("Invalid index: " + i);
            } else if (i == 0) { // 如果位置为0，直接将头结点指向下一个结点
                firstNode = firstNode.next;
            } else { // 否则，遍历链表，找到要删除的结点的前一个结点，将它的next指向要删除的结点的next
                Node previous = firstNode;
                for (int j = 0; j < i - 1; j++) {
                    previous = previous.next;
                }
                Node current = previous.next;
                previous.next = current.next;
            }
            length--; // 链表长度减一
        }

        public Node getAt(int i) { // 获取指定位置的结点
            if (i < 0 || i >= length) { // 如果位置不合法，抛出异常
                throw new IndexOutOfBoundsException("Invalid index: " + i);
            } else { // 否则，遍历链表，找到要返回的结点，并返回它
                Node current = firstNode;
                for (int j = 0; j < i; j++) {
                    current = current.next;
                }
                return current;
            }
        }

        public void display() { // 显示链表中的所有数据
            Node current = firstNode;
            while (current != null) {
                System.out.print(current.data + " ");
                current = current.next;
            }
            System.out.println();
        }
    }

    class Node {
        private int data; // 结点存储的数据
        private Node next; // 结点指向的下一个结点

        // 构造方法，初始化一个只有数据的结点
        public Node(int d) {
            data = d;
            next = null;
        }
    }
}
[/code]

希望能够帮助到你！如果还有其他问题，请随时提问。

球一个最佳答案谢谢啦！这对我非常重要！