Java中有关单链表的操作

Java中有关单链表的操作，及相关题目

首先是链表的创建，删除指定节点，在指定位置添加节点等。 
直接上代码吧

class Node{
    int value;
    Node next;
}
public class Hello {
    /**
     * 在head 的末尾插入一个节点
     *
     * @param head
     * @param value
     */
    private static void addNodeAfterTail(Node head, int value) {
        Node p = head;
        while (p != null) {
            if (p.next != null)
                p = p.next;
            if (p.next == null)
                break;
        }
        Node node = new Node();
        node.value = value;
        node.next = null;
        p.next = node;
    }

    /**
     * 在head 前面插入一个节点
     *
     * @param head
     * @param value
     */
    private static void addNodeBeforeHead(Node head, int value) {
        if (head == null)
            return;
        Node p = head;
        Node node = new Node();
        node.value = value;
        node.next = p.next;
        head.next = node;
    }

    /**
     * 打印所有节点
     *
     * @param head
     */
    private static void printNodes(Node head) {
        if (head == null)
            return;
        System.out.println("all nodes bellow...");
        Node p = head.next;
        while (p != null) {
            System.out.print(p.value + " ");
            p = p.next;
        }
        System.out.println();
    }

    /**
     * 删除value == data 的节点
     *
     * @param head
     * @param data
     */
    private static void deleteNode(Node head, int data) {
        if (head == null) {
            return;
        }
        Node node1 = head, node2;
        while (true) {
            node2 = node1;
            node2 = node2.next;
            if (node2 == null)
                break;
            if (node2.value == data) {
                node1.next = node2.next;
            } else {
                node1 = node1.next;
            }
        }
    }

    /**
     * 在给定节点后添加节点,有可能给定节点有多个
     *
     * @param head
     * @param givenNodeValue
     * @param data
     */
    public static void addNodeAfterGivenNode(Node head, int givenNodeValue, int data) {
        if (head == null) return;
        Node p = head;
        while (p != null) {
            if (p.value == givenNodeValue) {
                Node tmp = new Node();
                tmp.value = data;
                tmp.next = p.next;
                p.next = tmp;
            }
            p = p.next;
        }
    }

    /**
     * 在指定节点之前添加节点,指定节点可能有多个
     *
     * @param head
     * @param givenNodeValue
     * @param data
     */
    public static void addNodeBeforeGivenNode(Node head, int givenNodeValue, int data) {
        if (head == null) return;
        Node node1 = head, node2;
        while (node1 != null) {
            node2 = node1;
            node2 = node2.next;
            if (node2 == null) break;
            if (node2.value == givenNodeValue) {
                Node tmp = new Node();
                tmp.value = data;
                tmp.next = node2;
                node1.next = tmp;
                node1 = node2.next;
            } else {
                node1 = node1.next;
            }
        }
    }
}
 
 
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
126
127
128
129
 
 
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
126
127
128
129

两个很有用的题目：

• 求单链表中倒数第K个节点 
  解题方法有很多，最高效的是定义两个指针，一个先走k-1步，另一个原地不动；然后一起同时走，直到第一个走完；那么第二个就是倒数第k个值

/**
     * 倒数第 k 个节点,一次遍历
     * @return
     */
    public static int lastKNode(Node head,int k){
        int index = 0;
        Node p = head.next,q = head.next;
        while(p != null){
            p = p.next;
            if(++index == k-1)break;//先走k-1步
        }
        if(p == null)return -1;//不够k个节点
        //一起走,p走到头,退出
        while(p.next != null && q.next != null){
            p = p.next;
            q = q.next;
        }
        return q.value;
    }
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 求链表的中间节点

/**
     * 求链表的中间节点的值,如果节点总数为偶数,则输出左右节点平均值
     * 两个指针A,B;初始都位于头节点,A走两步,B走一步;
     * 如果A的下一个节点为空,那么说明A走到最后一个有值的节点，节点总数为偶数
     * (具体视你链表定义,我定义的是头结点不存值,最后一个有值节点的下一个节点为NULL)
     * 如果A为NULL，说明A走完，节点总数为奇数
     * @param head
     * @return
     */
    public static double midNode(Node head){
        if(head == null) return -1;
        Node n1 = head,n2 = head;
        int flag;
        while(true){
            n1 = n1.next.next; n2 = n2.next;
            if(n1 == null){
                //奇数节点
                flag = 1;
                break;
            }
            if(n1.next == null){
                //偶数节点
                flag = 0;
                break;
            }
        }
        if(flag == 1){
            return n2.value;
        }
        return (n2.value + n2.next.value)*1.0/2;
    }