leetcode链表反转思路以及代码

 要将这个链表反转解决思路有两种，一是进行迭代，二是进行递归

迭代

进行迭代操作的思路是，因为链表为单向，只能访问下一个节点，所以如果我们将箭头反向之后，是找不到下一个节点的，所以要将下一个节点保存。

next=head->next

因为要将箭头反向所有我们要将节点2指向节点1，因此我们还需要一个变量保存当前节点的上一个节点，头节点的上一个节点为空。

prev=null

因此我们的算法核心就是

head->next=prev

现在我们处理好了头结点反向的事情

然后我们因为对这个过程进行循环

因为不知道循环次数所以选中while循环

while的结束条件就是当前节点不为null

所以再引入一个变量cure因此可以得到算法

public static ListNode iterate(ListNode head){
        ListNode curr,next ,prev = null;
        curr = head;
        while (curr != null){
            /*next 为下一个节点，curr为当前节点，prev为前一个节点，首先将当前节点的下一个节点保存
                    然后将上一个节点赋值给当前节点的下一个节点，
                    然后将上一个节点改为当前节点，
                    最后将当前节点的下一个节点改为当前节点进行下一次迭代
            */

            next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
}

第二种思路递归

 

递归

核心思路就是将head->next->next = head

head->next=null

然后因为这样无法找到当前节点的下一个节点，因此我们将从链表最后一个节点进行递归，这样就可以解决这个问题。

public static ListNode recursion(ListNode head){
    /*
    递归的思路是找到最后一个元素，然后进行反转，最后返回反转后的链表
    1、对head进行判断，如果head为空或者head的下一个节点为空，则返回head,因为这种情况无需反转，而且会报空指针
    2、然后进行寻找链表的最后一个节点，寻找到最后一个节点node5之后，对node5进行算法操作，操作完成后node5指向node4
    3、调用自身此时new_head=head.next为node4再对node4进行了算法操作，操作完成后node4指向node3
    4、一直重复这个过程直到head.next为null，完成了反转，并且将最后一个节点进行了返回
     */
    if(head == null || head.next == null){
        return head;
    }
    //使用递归找到最后一个元素
    ListNode new_head=recursion(head.next);
    head.next.next = head;
    head.next = null;

    return new_head;
}

完整代码 

package leetcode30;

import java.util.List;

public class linkedList {

    //定义链表以及链表的构造函数
    static class ListNode {
        int val;
        ListNode next;

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

    //迭代法反转链表iterate迭代
    public static ListNode iterate(ListNode head){
            ListNode curr,next ,prev = null;
            curr = head;
            while (curr != null){
                /*next 为下一个节点，curr为当前节点，prev为前一个节点，首先将当前节点的下一个节点保存
                        然后将上一个节点的值赋值给当前节点的下一个节点，
                        然后将上一个节点改为当前节点，
                        最后将当前节点的下一个节点改为当前节点进行下一次迭代
                */

                next = curr.next;
                curr.next = prev;
                prev = curr;
                curr = next;
            }
            return prev;
    }


    //递归法反转链表recursion递归
    public static ListNode recursion(ListNode head){
        /*
        递归的思路是找到最后一个元素，然后进行反转，最后返回反转后的链表
        1、对head进行判断，如果head为空或者head的下一个节点为空，则返回head,因为这种情况无需反转，而且会报空指针
        2、然后进行寻找链表的最后一个节点，寻找到最后一个节点node5之后，对node5进行算法操作，操作完成后node5指向node4
        3、调用自身此时new_head=head.next为node4再对node4进行了算法操作，操作完成后node4指向node3
        4、一直重复这个过程直到head.next为null，完成了反转，并且将最后一个节点进行了返回
         */
        if(head == null || head.next == null){
            return head;
        }
        //使用递归找到最后一个元素
        ListNode new_head=recursion(head.next);
        head.next.next = head;
        head.next = null;

        return new_head;
    }



        public static void main(String[] args) {
            ListNode node5 = new ListNode(5, null);
            ListNode node4 = new ListNode(4, node5);
            ListNode node3 = new ListNode(3, node4);
            ListNode node2 = new ListNode(2, node3);
            ListNode node1 = new ListNode(1, node2);
//            ListNode head = iterate(node1);
//            System.out.println(head);
            ListNode prev =recursion(node1);
            System.out.println(prev);



        }


}

 

以上就是链表反转的两种思路