反转链表 java实现

题目描述：

给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

数据范围： 0≤n≤10000≤n≤1000

要求：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n) 。

如当输入链表{1,2,3}时，

经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。

以上转换过程如下图所示：

给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

数据范围： 0≤n≤10000≤n≤1000

要求：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n) 。

如当输入链表{1,2,3}时，

经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。

以上转换过程如下图所示：

示例1

输入：{1,2,3}

返回值：{3,2,1}

示例2

输入：{}

返回值：{}

说明：

空链表则输出空                                

解题思路：

首先写一个链表节点类

public class ListNode {
    int val;
    ListNode next = null;
    public ListNode(int val) {
        this.val = val;
    }

}

该链表节点有val和next属性，其中next表示，指向的下一个链表节点

链表反转构思如下：

创建两个链表节点pre、next，用来保存节点的前后节点信息，从而进行反向重构链接

过程如下所示：

1.next = head.next;

2.head.next = pre;

3.pre = head;

4.head = next;

循环以上操作，直到head=null

 

public ListNode ReverseList (ListNode head) {
        // 定义两个节点，方便存放前后节点
        ListNode pre = null;
        ListNode next = null;

        //如果节点为空，证明链表为空
        if (head == null){
            return null;
        }

        //如果不为空就循环遍历链表，将链表逆向输出
        while(head != null){
            //保存head节点的next值
            next = head.next;
            //将head的next指向pre
            head.next = pre;
            //继续下一个节点，让pre=head
            pre = head;
            //head往后指向下一个节点
            head = next;
        }
        return pre;
    }

编写测试程序，创建节点{1,2,3}，进行测试输出{3,2,1}

@Test
    public void test(){
        ListNode head = new ListNode(1);
        ListNode head2 = new ListNode(2);
        ListNode head3 = new ListNode(3);
        head.next = head2;
        head2.next = head3;

        ListNode listNode = ReverseList(head);

        ListNode next = null;
        while (listNode != null){
            next = listNode.next;
            System.out.print(listNode.val+", ");
            listNode = next;
        }
    }

输出结果如下：

新人一枚，不正确之处多多包涵