剑指 Offer 链表专题

一、剑指 Offer 18. 删除链表的节点

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。

返回删除后的链表的头节点。

注意：此题对比原题有改动

示例 1:

输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:

输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

说明：

题目保证链表中节点的值互不相同
若使用 C 或 C++ 语言，你不需要 free 或 delete 被删除的节点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        if(head.val == val)
            return head.next;
        ListNode pre = head,curent = head.next;
        while(curent!=null && curent.val!=val){
            pre = curent;
            curent = curent.next;
        }
        if(curent!=null){
            pre.next = curent.next;
        }
        return head;
    }
}

二、剑指 Offer 22. 链表中倒数第k个节点

1、题目：

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

示例：

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

2、思路与代码：

（方法一）最简单的做法

　　　先统计链表的长度length，再往前走length-k步，直接返回。

　　时间复杂度：O（n+n-k）

　　空间复杂度：O(2)

class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        int count=0;
        ListNode res = head;
        while(head!=null){
            count++;
            head = head.next;
        }
        int s = count-k;
        while(s!=0){
            res = res.next;
            s--;
        }
        return res;
    }
}

（方法二）双栈

　　第一个栈s1装所有节点，再将s1中的前k个节点放到栈s2中，这样，在s2中的头部往下，就是倒数第k个节点往后，再将s2中的节点依次pop，放到链表res后面就可以了。

　　时间复杂度：O(n+k+k) = O(3n)

　　空间复杂度：O(1)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        Stack<ListNode> s1 = new Stack<ListNode>();
        Stack<ListNode> s2 = new Stack<ListNode>();
        ListNode cur = head;
        while(cur!=null){
            s1.push(cur);
            cur = cur.next;
        }
        int i=0;
        while(i!=k){
            i++;
            s2.push(s1.pop());
        }
        //res代表整个链表（相当于LinkList），循环中不能使用；
        //r在循环中充当迭代作用的节点（相当于ListNode），需要一直往下next；
        ListNode res = s2.pop();
        ListNode r = res;
        while(!s2.empty()){
            r.next = s2.pop();
            r = r.next;
        }
        return res;
    }
}

（方法三）双指针

　　使用两个双指针pre和back，第一个指针pre先往前走k步，之后两个指针一起开始走，当第一个指针==null时，说明第一个指针pre已经走到尾部了，这样直接返回第二个指针back即可，因为两个之间的差距始终保持在k范围，所以此时back表示的就是倒数第k个节点。

　　时间复杂度：O(n)

　　空间复杂度：O(1)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode pre=head,back=head;
        for(int i=0;i<k;i++)
            pre = pre.next;
        while(pre!=null){
            pre = pre.next;
            back = back.next;
        }
        return back;
    }
}

三、剑指 Offer 24. 反转链表

1、题目：

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

限制：

0 <= 节点个数 <= 5000

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/fan-zhuan-lian-biao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2、思路与代码：

（方法一）栈

　　将所有节点都push到栈s1中，再将s1中的节点依次pop，组成新的链表，但是使用双栈解决可能会出现错误”Error - Found cycle in the ListNode“，原因是出现循环节点，如输入12345，压入栈中再弹出是54321，当s1依次pop后，最后只剩一个节点1时，因为将1节点pop后执行了c = c.next后跳出循环，此时1的next实际上是2，然后又因为在循环中2的next又是1，这两个你指我我指你，就造成循环了，所以需要在跳出循环后将最后一个节点的next设为null。

　　时间复杂度：O(2n)

　　空间复杂度：O(1)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null)
            return null;
        Stack<ListNode> s1 = new Stack<ListNode>();
        ListNode cur = head;
        while(cur!=null){
            s1.push(cur);
            cur = cur.next;
        }
        ListNode res = s1.pop();
        ListNode c = res;
        while(!s1.empty()){
            // System.out.print(s1.pop().val);
            c.next = s1.pop();
            c = c.next;
        }
        c.next = null;//不然会有循环错误
        return res;
    }
}

（方法二）双指针

时间复杂度
空间复杂度

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        //双指针
        ListNode cur = head,pre = null;
        while(cur!=null){
            ListNode tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
}

（方法三）递归+回溯

　　时间复杂度 O(N)：遍历链表使用线性大小时间。

　　空间复杂度 O(N)：遍历链表的递归深度达到 N ，系统使用 O(N)大小额外空间。

class Solution {
    public ListNode reverseList(ListNode head) {
        return recur(head, null);    // 调用递归并返回
    }
    private ListNode recur(ListNode cur, ListNode pre) {
        if (cur == null) return pre; // 终止条件
        ListNode res = recur(cur.next, cur);  // 递归后继节点，直到cur为null
        cur.next = pre;              // 回溯，修改节点引用指向5->4->3....
        return res;                  // 返回反转链表的头节点
    }
}

四、剑指 Offer 25. 合并两个排序的链表

1、题目：

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
限制：

0 <= 链表长度 <= 1000

注意：本题与主站 21 题相同：https://leetcode-cn.com/problems/merge-two-sorted-lists/

2、思路与代码：

　　l1 和 l2比，若l1小则加入res链表中，l1指向下一个，继续和 l2 比，重复操作。（有重复相同动作的可以考虑递归）

　　时间复杂度：O(2n)

　　空间复杂度：O(1)

注意：

　　①若初始化一个链表res=null，后面第一个用到的是res.next，这样会报空指针错误。

　　②若不想要链表第一个值就return res.next。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode res = new ListNode(0);
        ListNode r = res;
        while(l1!=null&&l2!=null){
            if(l1.val>l2.val){
                r.next = l2;
                l2 = l2.next;
            }else{
                r.next = l1;
                l1 = l1.next;
            }
            r = r.next;
        }
        r.next = l1==null?l2:l1;
        return res.next;
    }
}

posted @ 2022-09-16 12:14 湘summer 阅读(36) 评论(0) 编辑收藏举报

刷新页面返回顶部

湘summer

剑指 Offer 链表专题

公告