单链表逆置-java（递归与非递归）

单链表逆置-java（递归与非递归）

结点是一个自定义的类Node：

private class Node {
    public int value;
    public Node nextNode;
    public Node(int value) {
        this.value = value;
    }
}
 
 
1
2
3
4
5
6
7
 
 
1
2
3
4
5
6
7

递归方法用的是栈的思想，想把头结点入栈，接着头结点的下一个结点入栈，直到尾结点位置， 
截止依次把栈内的元素出栈，并更换其下一个结点对应的对象：

/**
 * 逆置单链表（递归）
 * @param head 头结点
 * @return 逆置后的头结点
 */
private static Node revert(Node head) {
    if (head == null || head.nextNode == null) {
        // 到达尾结点
        return head;
    }
    // 一直入栈
    Node revertHead = revert(head.nextNode);
    // 出栈并赋值nextNode对象
    head.nextNode.nextNode = head;
    head.nextNode = null;
    // 返回尾结点（逆置后的头结点）
    return revertHead;
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

非递归的方法其实就是顺着头结点往尾结点便利，便利期间把每个结点的nextNode替换掉， 
替换过程需要注意临时存储下一个结点：

/**
 * 逆置单链表（非递归）
 * @param head 头结点
 * @return 逆置后的头结点
 */
private static Node revert2(Node head) {
    Node pre = head;
    Node cur = head.nextNode;
    Node tmp;
    // 头结点的nextNode应该要置空
    pre.nextNode = null;
    while (cur != null) {
        // 先存放nex结点
        tmp = cur.nextNode;
        // 修改next结点指向pre
        cur.nextNode = pre;
        pre = cur;
        cur = tmp;
    }
    return pre;
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

验证：

1. 接着初始化一个单链表，
2. 调用递归方式将链表逆置，并输出
3. 调用非递归方式将链表再次逆置（还原到最初状态），并输出

代码如下：

Node head = new Node(0);
Node cur = null;
Node tmp;
for (int i = 1; i <= 10; i++) {
    tmp = new Node(i);
    if (i == 1) {
        head.nextNode = tmp;
    } else {
        cur.nextNode = tmp;
    }
    cur = tmp;
}

// 递归方式
head = revert(head);
System.out.println("递归方式");
printNodes(head);

// 循环方式
head = revert2(head);
System.out.println("循环方式");
printNodes(head);
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

其中printNodes是输出方法：

private static void printNodes(Node head) {
    System.out.print(head.value + "\t");
    while (head.nextNode != null) {
        System.out.print(head.nextNode.value + "\t");
        head = head.nextNode;
    }
    System.out.println();
}
 
 
1
2
3
4
5
6
7
8
 
 
1
2
3
4
5
6
7
8

输出结果：