算法之链表反转

转载于https://www.toudo.cn/article/20

链表反转两种实现方法

迭代法

实现步骤

单向链表的最后一个节点肯定是指向null，链表反转也就是将尾结点别为头结点。

• 第一步：声明pre指针并指向null，cur 指针指向当前节点，tmp指针 指向cur.next，断开cur.next 指向pre
• 第二步：移动 pre 指针到节点1，cur指针到节点2，tmp指针到节点3，继续断开cur.next节点指向前一个节点。
• 依次类推重复上面的步骤

代码实现

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

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;       
        while(cur != null){
            ListNode tmp =  cur.next;
            cur.next = pre; 
            pre = cur;
            cur = tmp; 
        }
        return pre;
    }

}

复杂度分析

• 时间复杂度：O(n)O(n)，其中 nn 是链表的长度。需要遍历链表一次。
• 空间复杂度：O(1)O(1)。

递归法

实现步骤

代码实现

public class ListNode {
    int val;
    ListNode next;
    ListNode() {}
    ListNode(int val) { this.val = val; }
    ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}
public ListNode reverseList(ListNode head) {
	if(head == null || head.next == null){
		return head;
	}
	ListNode ret = reverseList(head.next);
	head.next.next = head;
	head.next = null;
	return ret;
}

时间复杂度分析

• 时间复杂度：O(n)，其中 n 是链表的长度。需要对链表的每个节点进行反转操作。
• 空间复杂度：O(n)，其中 n 是链表的长度。空间复杂度主要取决于递归调用的栈空间，最多为 n 层。