链表的反转

反转

1 -> 2 -> 3 -> null

反转后 3 ->2 ->1 -> null

返回头节点

单链表反转

基本思想

• 单链表的每个节点有一个next指针指向其下一个节点
• head指针指向当前节点
• pre指针指向当前节点前一个节点
• next指针指向当前节点后一个节点
• 反转过程中，保证head的next指针指向了head的前一个节点，即反转

代码

//单链表
public class Node{
    public int value;
    public Node next;
    public Node(int data){
        value = data;

    }
}

/**
 * 反转单链表
 * @param head
 * @return
 */
public static Node reverseLinkedList(Node head){

    //定义pre节点，指向当前节点的前一个节点
    Node pre = null; //当前head节点为头节点，所以前一个节点为空
    Node next = null; //next节点,用于指向head的下一个节点

    //遍历单链表
    while (head != null){
        //将当前节点的下一个节点赋给next
        next = head.next;
        //当前节点的next指针指向pre,调整next指针
        head.next = pre;
        //pre后移
        pre = head;
        //head后移
        head = next;
    }
    return pre;
}

复杂度分析

• 时间复杂度：O(n) -> 遍历了单链表
• 额外空间复杂度：O(1) -> 额外定义了有限个变量，pre next

双向链表反转

基本思想

• 双向链表的每个节点有一个last指针指向其上一个节点，有一个next指针指向其下一个节点
• head表示当前节点
• 用next节点保存当前节点的next节点
• 用pre节点保存当前节点的last节点
• 当前节点head的next指针指向当前节点前一个节点pre
• 当前节点head的last指针指向当前节点后一个节点next
• pre节点后移，head节点（当前节点）后移

代码

//双向链表
public class DoubleNode{
    public int value;
    public DoubleNode last; // 左指针，指向前一个节点
    public DoubleNode next; // 右指针，指向后一个节点

    public DoubleNode(int data){
        value = data;
    }
}

public static DoubleNode reverseDoubleList(DoubleNode head){
    //定义pre节点指向当前节点前一个节点
    DoubleNode pre = null; //当前节点为头节点，所以前一个节点为null
    //定义next节点指向当前节点后一个节点
    DoubleNode next = null;

    while (head != null){
        //next节点指向head的下一个节点
        next = head.next;

        //head的next指针指向pre节点（原本next指针指向next节点）
        head.next = pre;
        //head的last指针指向next节点（原本last指针指向pre节点）
        head.last = next;

        //pre节点后移
        pre = head;
        //head节点houyi
        head = next;
    }

    return pre;
}

复杂度分析

• 时间复杂度：O(n) -> 遍历了双向链表
• 额外空间复杂度：O(1) -> 额外定义了有限个变量，pre next