反转单链表的5种方式(Reverse Linked List)

·  阅读 197
反转单链表的5种方式(Reverse Linked List)
  • 原题是 leetcode 206题 题目如下
/*
 * @lc app=leetcode id=206 lang=javascript
 *
 * [206] Reverse Linked List
 */
/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
    
}
复制代码

解法一:利用数组 反转(缺点增加额外空间)

  • 第一步:先将单链表所有节点(引用类型)存入一个数组
  • 第二步:反转数组
  • 第三步:数组第一个节点指向第二个节点,第二个节点指向第三个节点, ... ... 最后一个节点指向 null
  • 将数组第一个元素(反转后的单链表第一个节点)返回,大功告成

完整代码:

var reverseList = function(head) {
    // method 1  利用数组 反转(缺点增加额外空间)
    let arr = [];
    let root = head;
    if (!head || !head.next) {
        return head;
    }
    while(root) {
        arr.push(root);
        root = root.next;
    }
    arr.reverse();
    let len = arr.length;
    for (let i = 0; i < len; i++) {
        arr[i+1] && (arr[i].next = arr[i+1]);
        !arr[i+1] && (arr[i].next = null);
    }
    return arr[0]
};
复制代码

解法二:利用两个指针 pre curr 每次往下移动一位

完整代码:

var reverseList = function(head) {
    if (!head || !head.next) {
        return head;
    }
    let pre = head;
    let curr = pre.next;
    let last = curr.next;
    pre.next = null; // 原来的第一个节点 必然指向 null
    while (curr) {
        last = curr.next; // 保留下一个节点
        // 改变指向
        curr.next = pre;
        // pre curr 向下移动一位
        pre = curr;
        curr = last;
    }
    // 最后 curr 必然为 null,pre为之后一个元素,也就是新的单链表奶的似一个节点
    return pre;
};
复制代码

解法三:在单链表前增加一个辅助节点 pre

思路:

  • 第一步:增加一个辅助节点 pre
  • 第二步:从第二个节点开始,都插入到 pre 的后面

完整代码:

var reverseList = function(head) {
    // method 3 在单链表前面 加一个辅助节点pre,
    // 然后从第二个节点开始 插入到pre后面
    function ListNode(val) {
        this.val = val;
        this.next = null;
    }
    if (!head || !head.next) {
        return head;
    }
    let pre = new ListNode();
    pre.next = head; // 辅助节点 pre
    let root = head;
    while (root) {
        let n = root.next;
        if (root === head) {
            root.next = null;
        } else {
            root.next = pre.next;
            pre.next = root;
        }
        root = n;
    }
    return pre.next;
}
复制代码

解法四:递归

  • 递归的方式我个人感觉没有其他方式 好理解

完整代码:

var reverseList = function(head) {
    //  method 4 递归去实现
    if (!head || !head.next) {
        return head;
    }
    let originHead = head;
    let rootHead;
    function recursive(node) {
        let nextNode = node.next;
        if(!nextNode) {
            rootHead = node;
            return node;
        }
        let n = recursive(nextNode);
        n.next = node;
        if (node === originHead) {
            node.next = null;
            return rootHead;
        } else {
            return node;
        }
        
    }
    return recursive(head);
}
复制代码

解法五:巧妙方案

  • 该方法巧妙的利用了一个中间变量 temp
// method 5 终极方案
var reverseList = function(head) {
    var temp = null;
    while(head){
         temp = {
             val:head.val,
             next:temp //这个 temp 每次循环指向的是上一个节点
         };
        head=head.next
    }
    return temp;
};
复制代码

写在最后:

反转单链表是在面试环节经常遇到的题目,在遇到时,我们可以先说出解法一、二、三、四 到这里基本可以让面试官满意了,最后再拿出终极方案五,必有奇效

分类:
前端
标签:
分类:
前端
标签:
收藏成功!
已添加到「」, 点击更改