java链表ListNode及其常用方法实现_java listnode csdn

一：单向链表介绍
链表是一种数据结构，和数组同级。比如，Java中我们使用的ArrayList，实现原理是数组。而LinkedList的实现原理就是链表。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。
单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它能知道下一个结点的存储位置。由N各节点（Node）组成单向链表，每一个Node记录本Node的数据及下一个Node。向外暴露的只有一个头节点（Head），我们对链表的所有操作，都是直接或者间接地通过其头节点来进行的。

上图中最左边的节点即为头结点（Head），但是添加节点的顺序是从右向左的，也就是尾插。最先添加的节点（Head）对下一节点的引用可以为空。引用是引用下一个节点的地址而非下一个节点的对象。因为有着不断的引用，所以头节点就可以操作所有节点了。
下图描述了单向链表存储情况。存储是分散的，每一个节点只要记录下一节点，就把所有数据串了起来，形成了一个单向链表。

节点（Node）是由一个需要储存的对象(val或者data)及对下一个节点的引用(Node.next)组成的。也就是说，节点拥有两个成员：储存的对象、对下一个节点的引用。下面图是具体的说明：

***二、具体实现代码

class ListNode{
    public int val ; // 节点的保存的内容
    public ListNode next = null;  节点的引用，指向下一节点
    public ListNode(int val)
    {
        this.val = val;
    }
}

public class MyList {
    private ListNode head = null; //头节点

   
    public boolean add(int a) {  //添加新节点
        ListNode newNode = new ListNode(a);//实例化一个新节点a
        if (head == null) { //若头节点为空，新节点赋值给头节点
            head = newNode;
            return true;
        }
        ListNode cur = head;  //若头节点不为空，用cur代替head进行操作。防止修改head的值
        while (cur.next != null) { //遍历到最后一个节点
            cur = cur.next;
        }
        cur.next = newNode ; //让上一个节点的next指向新节点，完成连接
        return true;
    }

    public boolean delete(int a){ //删除指定节点
        if(head == null){  //若头节点为空，返回false
            return false; 
        }
        if(head.val == a){ 
            head = head.next;
            return true;
        }
        ListNode cur = head; //用cur代替head进行操作。防止修改head的值（以下不再解释）
        while (cur.next != null){ //遍历所有节点
            if(cur.next.val == a){//对cur.next节点进行判断，如果是要删除的，直接让cur.next指向被删除节点的next节点。即为：cur.next = cur.next.next;
                cur.next = cur.next.next;
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    public int size(){  //返回节点长度
        int flag = 0;
        ListNode cur = head;
        while(cur != null){
            flag++;
            cur =cur.next;
        }
        return flag;
    }

    public int find(int a){  //查找节点，返回下标
        ListNode cur = head;
        int flag = 0;
        while(cur.next != null){
            if(cur.val != a){
                flag++;
                cur = cur.next;
            }
            return flag;
        }
        return -1;
    }

    public ListNode get(int x){ //用下标查找节点
        if(head == null){
            return null;
        }
        ListNode cur = head;
            for (int i = 0; i < x; i++) {
                cur = cur.next;
            }
            return cur;
    }
}

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

链表的其他操作

//链表反转
public ListNode reverse(ListNode head){
        ListNode cur = head;
        ListNode prev = null;
        if(head == null){
            return null;
        }
        while(cur != null) {
            ListNode tem = cur.next;
            cur.next = prev;
            prev = cur;
            cur = tem;
        }
        return prev;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

//测试函数

public static void main(String[] args) {
        MyList list = new MyList();  
            list.add(1);
            list.add(2);
            list.add(3);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).val);
        }
        System.out.println("***************");
            System.out.println(list.get(2).val);
        System.out.println("***************");
            System.out.println(list.delete(2));
            System.out.println(list.find(2));
        System.out.println("***************");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行结果：

//add()，size()测试结果
1
2
3
***************
//get(2)测试结果
3
***************
//delete(2)测试结果
true
1
3
***************
//查找值为2的节点，返回下标
find(2)
1
***************
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17