冰寒刷题-算法相关内容 : 反转链表问题相关内容

题目描述

给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。
数据范围： 0\leq n\leq10000≤n≤1000
要求：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n) 。
如当输入链表{1,2,3}时，
经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。

代码实现

节点实现代码如下:

class ListNode(var `val`: Int) {
    var next: ListNode? = null
}

功能代码实现部分如下:

object Solution {
    /**
     * 在遍历链表时，将当前节点的next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。
     * 1. pre指针：用来指向反转后的节点，初始化为null
     * 2. cur变量: 当前节点指针
     * 3. 循环迭代中 Cur_next 节点，永远指向当前节点cur的下一个节点，并且反转过程中反转的关键是当前的节点指向其前一个节点(注意这不是双向链表，没有前驱指针，不断更新pre和更新当前节点指针
     *
     * 复杂度分析：
     * 时间复杂度：O(N)，其中 N 是链表的长度。需要遍历链表一次。
     * 空间复杂度：O(1)，常数空间复杂度
     * <img src="https://uploadfiles.nowcoder.com/images/20210719/583846419_1626706153454/2C7D195FD1E7D347D9205934864B3226">
     *
     * @param head ListNode类
     * @return ListNode类
     */
    fun ReverseList1(head: ListNode?): ListNode?  {
        var pre:ListNode? = null
        var cur: ListNode? = head
        while (cur != null) {
            val curNext: ListNode? = cur.next
            cur.next = pre
            pre = cur
            cur = curNext
        }
        // 为什么返回pre？因为pre是反转之后的头节点
        return pre
    }

    /**
     * 复杂度分析：
     * 时间复杂度：O(N)，其中 N 是链表的长度。需要对链表的每个节点进行反转操作。
     * 空间复杂度：O(N)，其中 N 是链表的长度。空间复杂度主要取决于递归调用的栈空间，最多为 N 层
     *
     * 使用递归函数，一直递归到链表的最后一个结点，该结点就是反转后的头结点，记作 ans
     * 此后，每次函数在返回的过程中，让当前结点的下一个结点的 next 指针指向当前节点。
     * 同时让当前结点的 next 指针指向NULL ，从而实现从链表尾部开始的局部反转
     * 当递归函数全部出栈后，链表反转完成。
     */
    fun ReverseList2(head: ListNode?): ListNode?{
        //特判：注意不要漏掉pHead->next==NULL的情况
        if (head?.next == null){
            return head
        }
        // 递归调用
        val ans = ReverseList2(head.next)
        //让当前结点的下一个结点的 next 指针指向当前节点
        head.next!!.next=head
        //让当前结点的下一个结点的 5 指针指向当前节点
        head.next=null

        return ans
    }
}