Sword24——反转链表

Sword24——反转链表

方法1——头插法

• 思路：定义一个新链表的哑铃节点，不断遍历将原链表的节点插入哑铃节点与其下一节点之间即可
• 特殊情况与临界分析：无
• 终止条件：原链表遍历完成
• 步骤：
  • 定义哑铃节点
  • 定义移动节点，下一节点
  • 循环条件：cur不为空
  • while循环
    • 保存原链表的下一节点
    • 当前节点cur插入哑铃节点的next节点之前
    • 当前节点cur插入哑铃节点之后
  • 返回哑铃节点的下一节点，即为新链表的头节点

    public ListNode reverseList(ListNode head) {
        // 定义哑铃节点
        ListNode dummy = new ListNode(-1);
        // 定义移动节点，下一节点
        ListNode cur = head, next;
        // while循环
        while (cur != null) {
            // 保存原链表的下一节点
            next = cur.next;
            // 插入哑铃节点的next节点之前
            cur.next = dummy.next;
            // 插入哑铃节点之后
            dummy.next = cur;
            // cur后移一个节点
            cur = next;
        }
        // 返回哑铃节点的下一节点
        return dummy.next;
    }

方法2——就地反转法

• 思路：定义一个原链表的哑铃节点，从头节点和其下一节点开始进行就地反转，即相当于将后一节点提前至dummy的next
• 特殊情况与临界分析：链表非空判断
• 终止条件：cur已经到达链表末尾
• 步骤：
  • 链表非空判断
  • 定义哑铃节点
  • 将哑铃节点的next指向head
  • 定义pre节点为头节点、cur节点为头节点的下一节点，开始就地反转
  • 循环条件：cur非空
  • while循环
    • pre的next指向cur的next
    • cur的next指向dummy的next
    • dummy的next指向cur
    • cur更换为pre的next节点
  • 返回哑铃节点的下一节点，即为新头节点

    public ListNode reverseList(ListNode head) {
        // 链表非空判断
        if (head == null) return head;
        // 定义哑铃节点
        ListNode dummy = new ListNode(-1);
        // 将其next指向head
        dummy.next = head;
        // 定义pre、cur
        ListNode pre = head, cur = head.next;
        // while循环
        while (cur != null) {
            // pre的next指向cur的next
            pre.next = cur.next;
            // cur的next指向dummy的next
            cur.next = dummy.next;
            // dummy的next指向cur
            dummy.next = cur;
            // cur更换为pre的next节点
            cur = pre.next;
        }
        // 返回哑铃节点的下一节点
        return dummy.next;
    }

方法3——迭代法

• 思路：只需要将不断将cur指向pre即可，此处可构造哑铃节点，也可直接将pre置空
• 特殊情况与临界分析：无
• 终止条件：当cur到达链表末尾
• 步骤：
  • 定义pre为空、cur为head
  • 循环条件：cur非空
  • while循环
    • cur的next指向pre
    • pre后移为cur
    • cur后移为其下一节点
  • 返回pre即为新头节点

    public ListNode reverseList(ListNode head) {
        // 定义pre、cur
        ListNode pre = null, cur = head;
        // while循环
        while (cur != null) {
            // cur的next指向pre
            cur.next = pre;
            // pre后移
            pre = cur;
            // cur后移
            cur = cur.next;
        }
        // 返回pre
        return pre;
    }

方法4——递归法

• 思路：一直往下找到倒数第二个节点，将其下一个节点的next指向自身，不断回溯即可
• 特殊情况与临界分析：链表为空或链表只有一个节点，必须所要的条件，否则无法退出递归
• 终止条件：链表倒数第二个节点找到，回溯完成即可
• 步骤：
  • 校验，即递归的终止条件
  • 开启递归
  • 将当前节点的next节点的next指向自身，即head.next.next = head
  • 将当前节点的next置空
  • 返回每次的头节点

    public ListNode reverseList(ListNode head) {
        // 校验，即递归终止条件
        if (head == null || head.next == null) {
            return head;
        }
        // 开启递归
        ListNode node = reverseList(head.next);
        // 将当前节点的next节点的next指向自身
        head.next.next = head;
        // 将当前节点的next置空
        head.next = null;
        // 向上传递节点
        return node;
    }