1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class MyClass {
    public int value;

    public MyClass(int value) {
        this.value = value;
    }
}

public class Main {
    private static void changeValue(MyClass myClass) {
        myClass.value = 20;
    }

    public static void main(String[] args) {
        MyClass myClass = new MyClass(10);
        System.out.println(myClass.value);
        changeValue(myClass);
        System.out.println(myClass.value);
    }
}

1
2
3
4
5
6

Node current = head; // 从链表的第一个节点（head）开始
while(current.next != null) { // 当前节点的“下一个”指针不为空时（即当前节点不是最后一个节点）
    System.out.println(current.data); // 获取当前节点的数据（如果需要的话）
    current = current.next; // 将当前节点指针指向下一个节点
}
System.out.println(current.data); // 输出最后一个节点的数据（如果需要的话）

1
2
3
4
5

// 头部插入方法需要一个参数 data 作为新节点的数据
Node newNode = new Node(); // 创建一个新节点
newNode.data = data; // 设置新节点的数据
newNode.next = head; // 将新节点的“下一个”指针指向原来的头节点
head = newNode; // 将新节点设置为头节点

1
2
3
4
5
6
7
8
9
10
11
12
13

// 尾部插入方法也需要一个参数 data 作为新节点的数据
Node newNode = new Node(); // 创建一个新节点
newNode.data = data; // 设置新节点的数据
newNode.next = null; // 将新节点的“下一个”指针设置为 null
if (head == null) { // 如果链表为空
    head = newNode; // 将新节点设置为头节点
} else {
    Node current = head; // 从头节点开始遍历
    while (current.next != null) { // 当前节点的“下一个”指针不为空时（即当前节点不是最后一个节点）
        current = current.next; // 将当前节点指针指向下一个节点
    }
    current.next = newNode; // 将最后一个节点的“下一个”指针指向新节点
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// 中间插入方法需要两个参数 data 和 index，分别表示新节点的数据和要插入的位置（从 0 开始）
if (index == 0) {
    // 实际上就是头部插入
    insertAtBeginning(data); // 由于已经有了头部插入方法，所以可以直接调用头部插入方法
} else {
    Node newNode = new Node(); // 创建一个新节点
    newNode.data = data; // 设置新节点的数据
    Node current = head; // 从头节点开始遍历
    for (int i = 1; i < index; i++) { // 遍历到要插入的位置的前一个位置
        current = current.next; // 如果还没到要插入的位置，就将当前节点指针指向下一个节点
    }
    // 到了要插入的位置后（此时 current 指向要插入的位置的前一个位置）
    newNode.next = current.next; // 将新节点的“下一个”指针指向当前节点的“下一个”指针指向的节点
    current.next = newNode; // 将当前节点的“下一个”指针指向新节点
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// 删除方法需要一个参数 index，表示要删除的节点的位置（从 0 开始）
if (index == 0) {
    // 实际上就是删除头节点
    Node temp = head; // 保存头节点
    head = head.next; // 将头节点指针指向头节点的“下一个”指针指向的节点
    temp = null; // 删除头节点，这一步实际上不是必要的
} else {
    Node current = head; // 从头节点开始遍历
    for (int i = 1; i < index; i++) { // 遍历到要删除的位置的前一个位置
        current = current.next; // 如果还没到要删除的位置，就将当前节点指针指向下一个节点
    }
    // 到了要删除的位置的前一个位置后（此时 current 指向要删除的位置的前一个位置）
    Node temp = current.next; // 保存要删除的节点
    current.next = temp.next; // 将前一个节点的“下一个”指针指向要删除节点的“下一个”指针指向的节点
    temp = null; // 删除要删除的节点
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

/**
 * 链表的节点
 */
class Node {
    /**
     * 节点的数据
     */
    public int data;
    /**
     * 节点的“下一个”指针
     */
    public Node next;
}

/**
 * 链表
 */
class MyLinkedList {
    private Node head = null;

    /**
     * 遍历链表，显示链表中的所有元素
     */
    public void traverse() {
        Node current = head; // 从链表的第一个节点（head）开始
        while (current.next != null) { // 当前节点的“下一个”指针不为空时（即当前节点不是最后一个节点）
            System.out.print(current.data + " "); // 获取当前节点的数据（如果需要的话）
            current = current.next; // 将当前节点指针指向下一个节点
        }
        System.out.print(current.data + " "); // 输出最后一个节点的数据（如果需要的话）
        System.out.println(); // 换行
    }

    /**
     * 在链表的开头插入一个新数据
     * @param data 新节点的数据
     */
    public void insertAtBeginning(int data) {
        // 头部插入方法需要一个参数 data 作为新节点的数据
        Node newNode = new Node(); // 创建一个新节点
        newNode.data = data; // 设置新节点的数据
        newNode.next = head; // 将新节点的“下一个”指针指向原来的头节点
        head = newNode; // 将新节点设置为头节点
    }

    /**
     * 在链表的末尾插入一个新数据
     * @param data 新节点的数据
     */
    public void insertAtEnd(int data) {
        // 尾部插入方法也需要一个参数 data 作为新节点的数据
        Node newNode = new Node(); // 创建一个新节点
        newNode.data = data; // 设置新节点的数据
        newNode.next = null; // 将新节点的“下一个”指针设置为 null
        if (head == null) { // 如果链表为空
            head = newNode; // 将新节点设置为头节点
        } else {
            Node current = head; // 从头节点开始遍历
            while (current.next != null) { // 当前节点的“下一个”指针不为空时（即当前节点不是最后一个节点）
                current = current.next; // 将当前节点指针指向下一个节点
            }
            current.next = newNode; // 将最后一个节点的“下一个”指针指向新节点
        }
    }

    /**
     * 在链表的指定位置插入一个新数据
     * @param data  新节点的数据
     * @param index 新节点的位置
     */
    public void insertAt(int data, int index) {
        // 中间插入方法需要两个参数 data 和 index，分别表示新节点的数据和要插入的位置（从 0 开始）
        if (index == 0) {
            // 实际上就是头部插入
            insertAtBeginning(data); // 由于已经有了头部插入方法，所以可以直接调用头部插入方法
        } else {
            Node newNode = new Node(); // 创建一个新节点
            newNode.data = data; // 设置新节点的数据
            Node current = head; // 从头节点开始遍历
            for (int i = 1; i < index; i++) { // 遍历到要插入的位置的前一个位置
                current = current.next; // 如果还没到要插入的位置，就将当前节点指针指向下一个节点
            }
            // 到了要插入的位置后（此时 current 指向要插入的位置的前一个位置）
            newNode.next = current.next; // 将新节点的“下一个”指针指向当前节点的“下一个”指针指向的节点
            current.next = newNode; // 将当前节点的“下一个”指针指向新节点
        }
    }

    /**
     * 删除链表指定位置的节点
     * @param index 要删除的节点的位置
     */
    public void deleteAt(int index) {
        // 删除方法需要一个参数 index，表示要删除的节点的位置（从 0 开始）
        if (index == 0) {
            // 实际上就是删除头节点
            Node temp = head; // 保存头节点
            head = head.next; // 将头节点指针指向头节点的“下一个”指针指向的节点
            temp = null; // 删除头节点，这一步实际上不是必要的
        } else {
            Node current = head; // 从头节点开始遍历
            for (int i = 1; i < index; i++) { // 遍历到要删除的位置的前一个位置
                current = current.next; // 如果还没到要删除的位置，就将当前节点指针指向下一个节点
            }
            // 到了要删除的位置的前一个位置后（此时 current 指向要删除的位置的前一个位置）
            Node temp = current.next; // 保存要删除的节点
            current.next = temp.next; // 将前一个节点的“下一个”指针指向要删除节点的“下一个”指针指向的节点
            temp = null; // 删除要删除的节点
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyLinkedList list = new MyLinkedList();
        list.insertAtBeginning(10);
        list.insertAtBeginning(5);
        list.insertAtEnd(15);
        list.traverse(); // 5 10 15
        list.insertAt(8, 2);
        list.traverse(); // 5 10 8 15
        list.deleteAt(1);
        list.traverse(); // 5 8 15
    }
}