算法<递归与非递归方式翻转单链表>

链表的节点定义：

public class ListNode {
    int val;
    ListNode next;
    ListNode(int x) {
        val = x;
    }
}

1.递归：

public class Demo {
    public ListNode reverseList(ListNode head) {
        //当前节点翻转过后必然是    其后继节点的后继节点，比如之前是1->2（当前节点是1），翻转过后变成2->1(当前节点的后继节点的后继节点是当前节点)
        if (head == null || head.next == null)
            return head;
        ListNode nextNode = head.next;
        ListNode newHead = reverseList(nextNode);
        nextNode.next = head;
        head.next = null;
        return newHead;
    }

    public static void main(String[] args) {
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        node1.next = node2;
        node2.next = node3;
        ListNode node = new Demo().reverseList(node1);
        while (node != null) {
            System.out.print(node.next == null ? node.val + "" : node.val + ",");
            node = node.next;
        }
    }
}

2.非递归

public class Demo {
    public ListNode reverseList(ListNode currentnode) {
        //当前节点的前驱结点
        ListNode prenode = null;
        //当前节点不为空的时候就执行
        while (currentnode != null) {
            //在翻转指针之前先记录下当前节点的后继节点
            ListNode nextnode = currentnode.next;
            //当前节点的指针指向当前节点的前驱
            currentnode.next = prenode;
            //在遍历到当前节点的后继节点之前先记录下当前节点作为后继节点的前驱
            prenode = currentnode;
            currentnode = nextnode;
        }
        return prenode;
    }

    public static void main(String[] args) {
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        node1.next = node2;
        node2.next = node3;
        ListNode node = new Demo().reverseList(node1);
        while (node != null) {
            System.out.print(node.next == null ? node.val + "" : node.val + ",");
            node = node.next;
        }
    }
}