【LC】移除链表元素, 链表的中间节点, 合并两个有序链表

小灰灰 2023-09-26 10:06 41阅读 0赞

![在这里插入图片描述][078b66f87e3c4e309d7f34d79c5776c4.gif_pic_center]✨**博客主页:**[ **XIN-XIANG荣**][_XIN-XIANG]  
✨**系列专栏:**[**【LeetCode/牛客刷题】**][LeetCode]  
✨**一句短话:** **难在坚持,贵在坚持,成在坚持!**

#### 文章目录 ####

*  1. 移除链表元素(lc203)
 *   *  题目描述:
     *  解题思路：
     *  代码实现：
     *  提交结果：
 *  2. 链表的中间节点(lc876)
 *   *  题目描述:
     *  解题思路：
     *  代码实现：
     *  提交结果：
 *  3. 合并两个有序链表(lc21)
 *   *  题目描述:
     *  解题思路：
     *  代码实现：
     *  提交结果：

## 1. 移除链表元素(lc203) ##

### 题目描述: ###

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

![img][]

**示例 1**：

输入：head = \[1,2,6,3,4,5,6\], val = 6

输出：\[1,2,3,4,5\]

**示例 2**：

输入：head = \[\], val = 1

输出：\[\]

**示例 3**：

输入：head = \[7,7,7,7\], val = 7

输出：\[\]

**提示**：

列表中的节点数目在范围 \[0, 10 ^ 4\] 内

1 <= Node.val <= 50

0 <= val <= 50

**来源**：力扣（LeetCode）

**链接**：[https://leetcode.cn/problems/remove-linked-list-elements][https_leetcode.cn_problems_remove-linked-list-elements]

### 解题思路： ###

遍历链表去判断节点元素是不是要删除的元素即可 , **做题需要提醒注意的是如果要删除的元素是头节点或者尾节点的处理** ;

由于**每次循环遍历都需要去访问节点中的元素** , **所以循环遍历的条件应当使用 cur.next != null 而不是 cur = null , 以保证在最后一次遍历时不会出现空指针异常的情况** ;

从题目中可以知道要处理的链表是**单链表** , 所以如果要**删除节点** , 那么需要先**找到要删除节点的前一个结点** ; 所以使用 cur.next.val == val 来判断当前节点的下一个节点是不是要删除的节点 , 此时cur指向的就是要删除节点的前一个节点 , 修改cur.next引用的指向即可 ;

还需要注意当遍历结束后 , 此时头节点还没有判断 , 这里不能忽略 , 再去判断一下即可 .

![img][img 1]

### 代码实现： ###

/**
     * Definition for singly-linked list.
     * 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 removeElements(ListNode head, int val) {
        
            if(head == null) {
        
                return null;
            }
            //从第二个元素开始判断
            ListNode cur = head;
            while(cur.next != null) {
        
                if(cur.next.val == val) {
        
                    cur.next = cur.next.next;
                }else {
        
                    cur = cur.next;
                }
            }
            //最后判断头节点
            if(head.val == val) {
        
                head = head.next;
            }
            return head;
        }
    }

### 提交结果： ###

![img][img 2]

## 2. 链表的中间节点(lc876) ##

### 题目描述: ###

给定一个头结点为 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

**示例 1**：

输入：\[1,2,3,4,5\]

输出：此列表中的结点 3 (序列化形式：\[3,4,5\])

返回的结点值为 3 。 (测评系统对该结点序列化表述是 \[3,4,5\])。

注意，我们返回了一个 ListNode 类型的对象 ans，这样：

ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.

**示例 2**：

输入：\[1,2,3,4,5,6\]

输出：此列表中的结点 4 (序列化形式：\[4,5,6\])

由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。

**提示**：

给定链表的结点数介于 1 和 100 之间。

**来源**：力扣（LeetCode）

**链接**：[https://leetcode.cn/problems/middle-of-the-linked-list][https_leetcode.cn_problems_middle-of-the-linked-list]

### 解题思路： ###

快慢指针的思想 , 定义两个节点引用 fast(快) 和slow(慢) , 然后两个引用同时去遍历链表 , fast一次走两步 , slow 一次走一步 , 最后show所指向的位置就是链表的中间节点 ;

注意节点个数为奇数和偶数的循环遍历的结束条件是不一样的 , 为**偶数** , **fast指向链表最后一个节点时(fast.next != null)** , 此时slow指向中间节点 ; 为**奇数** , **fast指向链表最后一个节点后面的空位置时(fast != null)** , slow指向中间节点 ;

所以循环条件为 fast != null && fast.next != null ; 这里 fast != null 要 fast.next != null 放在 fast.next != null 前面 , 否则会有空指针异常 ; 因为先要保证 fast != null 才能去访问 fast.next .

![img][img 3]

### 代码实现： ###

### 提交结果： ###

![img][img 4]

## 3. 合并两个有序链表(lc21) ##

### 题目描述: ###

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

![img][img 5]

**示例 1**：

输入：l1 = \[1,2,4\], l2 = \[1,3,4\]

输出：\[1,1,2,3,4,4\]

**示例 2**：

输入：l1 = \[\], l2 = \[\]

输出：\[\]

**示例 3**：

输入：l1 = \[\], l2 = \[0\]

输出：\[0\]

**提示**：

两个链表的节点数目范围是 \[0, 50\]

\-100 <= Node.val <= 100

11 和 12 均按 非递减顺序 排列

**来源**：力扣（LeetCode）

**链接**：[https://leetcode.cn/problems/merge-two-sorted-lists][https_leetcode.cn_problems_merge-two-sorted-lists]

### 解题思路： ###

这道题是将两个有序链表和并为一个新的链表 , 所以可以设置一个虚拟的头节点 , 将节点尾插到这个节点上 , 组成新的链表 , 然后返回第一个节点 , 注意不是返回我们设置的那个虚拟节点 ;

也可以不设置虚拟节点 , 用一个引用记录下来第一个节点就行 , 都差不多 ; 重点是如何在保证有序的情况下将节点进行尾插 , 其实也不难想 ;

同时去遍历两个链表 , 逐对去比较元素 , 将较小的一个进行尾插即可 ; 两个链表可能存在一个链表先遍完 , 另一个链表还没有遍历完 , 此时只需要将这个没有遍历完的剩余元素逐个进行尾插即可 .

### 代码实现： ###

/**
     * Definition for singly-linked list.
     * 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 mergeTwoLists(ListNode list1, ListNode list2) {
        
            //设置一个头节点
            ListNode newHead = new ListNode(-1);
            //记录合并的链表的尾节点位置
            ListNode tmp = newHead;
            while(list1 != null && list2 != null) {
        
                if(list1.val < list2.val) {
        
                    tmp.next = list1;
                    list1 = list1.next;
                }else {
        
                    tmp.next = list2;
                    list2 = list2.next;
                }
                tmp = tmp.next;
            }
            if(list1 != null) {
        
                tmp.next = list1;
            }
            if(list2 != null) {
        
                tmp.next = list2;
            }
            return newHead.next;
        }
    }

其他写法:  
核心思路与上面是一样的, 唯一的区别是这个写法没有另外设置一个新头节点.

class Solution {
        
        public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        
            if (list1 == null || list2 == null) {
        
                return list1 != null ? list1 : list2;
            }
            // 让head指向两个链表头节点中值较小的那一个
            ListNode head = list1.val <= list2.val ? list1 : list2;
            ListNode cur1 = head.next;
            ListNode cur2 = head != list1 ? list1 : list2;
            ListNode cur = head;
    
            while (cur1 != null && cur2 != null) {
        
                if (cur1.val <= cur2.val) {
        
                    cur.next = cur1;
                    cur1 = cur1.next;
                } else {
        
                    cur.next = cur2;
                    cur2 = cur2.next;
                }
                cur = cur.next;
            }
    
            if (cur1 != null) {
        
                cur.next = cur1;
            }
            if (cur2 != null) {
        
                cur.next = cur2;
            }
            return head;
        }
    }

### 提交结果： ###

![img][img 6]

[078b66f87e3c4e309d7f34d79c5776c4.gif_pic_center]: https://img-blog.csdnimg.cn/078b66f87e3c4e309d7f34d79c5776c4.gif#pic_center
[_XIN-XIANG]: https://blog.csdn.net/Trong_?spm=1000.2115.3001.5343
[LeetCode]: https://blog.csdn.net/trong_/category_11990219.html?spm=1001.2014.3001.5482
[img]: https://img-blog.csdnimg.cn/img_convert/530390864ab67e68d05ff0b270f05bb6.png
[https_leetcode.cn_problems_remove-linked-list-elements]: https://leetcode.cn/problems/remove-linked-list-elements
[img 1]: https://img-blog.csdnimg.cn/img_convert/4aef2e219c35230c0b44e18f016d12b3.png
[img 2]: https://img-blog.csdnimg.cn/img_convert/47bc7d5939c989812decbc7f0b61b6ee.png
[https_leetcode.cn_problems_middle-of-the-linked-list]: https://leetcode.cn/problems/middle-of-the-linked-list
[img 3]: https://img-blog.csdnimg.cn/img_convert/c4b429838a8d7e1769dd9fc8bc635a85.png
[img 4]: https://img-blog.csdnimg.cn/img_convert/c74d4e6f9ab444786600d19e9c24832f.png
[img 5]: https://img-blog.csdnimg.cn/img_convert/3d5ec46e02e7e9c4739c117666bad6d2.png
[https_leetcode.cn_problems_merge-two-sorted-lists]: https://leetcode.cn/problems/merge-two-sorted-lists
[img 6]: https://img-blog.csdnimg.cn/img_convert/fe85f2e21542ea0510ae049e1d8f782a.png