LeetCode链表（链表操作，反转链表，奇偶链表，排序链表）
文章目录
- 前言
-
- 1.链表定义
- 2.链表操作
- 3.技巧
- 链表常见操作
-
- 1.lc203 移除链表元素
- 2.lc2 两数相加
- 3.lc328 奇偶链表
- 反转链表
-
- 1.lc206 反转链表
- 2.lc92 反转链表II
- 链表排序
-
- 1.lc147 对链表进行插入排序
- 2.148. 排序链表
- 链表双指针
-
- 1.lc19 删除链表的倒数第 N 个结点
- 2.lc21 合并两个有序链表
- 3.lc24 两两交换链表中的节点
- 4.lc234 回文链表
前言
本篇文章更注重于链表自身的特点（如果是关于双指针，链表数组字符串中都会出现，所以这里列举几题，更详细的见双指针）
1.链表定义
链表是一种通过指针串联在一起的线性结构。链表中的每个元素实际上是一个单独的对象，而所有对象都通过每个元素中的引用字段链接在一起。链表的入口节点称为链表的头结点也就是head。
（1）单链表
每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。
Java定义：
// 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; }
}
（2）双链表
每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。
Java定义：
// Definition for doubly-linked list.
class DoublyListNode {
int val;
DoublyListNode next, prev;
DoublyListNode(int x) {val = x;}
}
（3）循环链表
链表首尾相连
2.链表操作
（1）删除节点
具体可以参见力扣：https://leetcode.cn/leetbook/read/linked-list/j47r3/
（2）添加节点
（3）反转链表
3.技巧
虚拟头节点+快慢指针！！！
循环过程一般采用while循环（因为链表获取不了索引，索引for不太方便）
链表常见操作
1.lc203 移除链表元素
力扣203链接
描述：
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点
示例：
输入：head = [1,2,6,3,4,5,6], val = 6 ； 输出：[1,2,3,4,5]
Solution：
（可以设置一个虚拟头节点，方便统一操作）
public ListNode removeElements(ListNode head, int val) {
if(head==null)
return head;
ListNode dummy = new ListNode(-1,head); // 设置虚拟头节点
ListNode pre = dummy; // 将虚拟头节点设置为前一节点
ListNode cur = head; // 将头节点设置为当前节点
while(cur!=null)
{
if(cur.val==val)
pre.next = cur.next;
else
pre = cur; // 前一节点后移
cur = cur.next; // 无论找没找到当前节点后移
}
return dummy.next;
}
2.lc2 两数相加
lc2链接
描述：
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。请你将两个数相加，并以相同形式返回一个表示和的链表。
示例：
输入：l1 = [2,4,3], l2 = [5,6,4] ； 输出：[7,0,8]
Solution：
模拟过程，主要是要处理进位。另外的技巧就是可以给位数少的添加前导0
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
// 开辟一个虚拟头结点
ListNode dummy = new ListNode(-1);
ListNode cur = dummy;
int cnt=0; // 初始进位为0
ListNode head = null;
while(l1!=null || l2!=null)
{
// 添加前导0，使两者位数相同
int n1 = l1 != null ? l1.val : 0;
int n2 = l2 != null ? l2.val : 0;
int sum = n1+n2+cnt;
cnt = sum/10;
cur.next = new ListNode(sum%10);
cur = cur.next;
if(l1!=null) l1 = l1.next;
if(l2!=null) l2 = l2.next;
}
if(cnt>0) cur.next = new ListNode(cnt%10);
return dummy.next;
}
3.lc328 奇偶链表
lc328链接
描述：
给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。第一个节点的索引被认为是 奇数 ， 第二个节点的索引为 偶数 ，以此类推
示例：
输入: head = [1,2,3,4,5] ； 输出: [1,3,5,2,4]
Solution：
模拟过程，将奇偶链表分开。基本功啊！
public ListNode oddEvenList(ListNode head) {
if(head==null || head.next==null) return head;
ListNode tmp = head.next;
ListNode odd = head;
ListNode even = tmp;
while(even!=null && even.next!=null)
{
odd.next = even.next;
odd = odd.next;
even.next = odd.next;
even = even.next;
}
odd.next = tmp;
return head;
}
反转链表
1.lc206 反转链表
lc206 链接
描述：
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表
示例：
输入：head = [1,2,3,4,5] ； 输出：[5,4,3,2,1]
Solution1：迭代法
双指针！
public ListNode reverseList(ListNode head) {
if(head==null)
return head;
ListNode pre = null;
ListNode cur = head;
while(cur!=null)
{
ListNode tmp = cur.next;
cur.next = pre;
pre = cur;
cur = tmp;
}
return pre;
}
Solution2：递归
2.lc92 反转链表II
lc92 链接
描述：
给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表
示例：
输入：head = [1,2,3,4,5], left = 2, right = 4 输出：[1,4,3,2,5]
Solution1：迭代法
挺烧脑的，需要好好模拟一下，简单说就是一种穿针引线的方法
public ListNode reverseBetween(ListNode head, int left, int right) {
ListNode dummy = new ListNode(-1,head); // 虚拟头节点
ListNode pre = dummy;
for(int i=1;i<left;i++)
{
pre = pre.next;
}
ListNode cur = pre.next;
for(int i=left;i<right;i++)
{
ListNode nextNode = cur.next;
cur.next = nextNode.next;
nextNode.next = pre.next;
pre.next = nextNode;
}
return dummy.next;
}
Solution2：递归法
链表排序
链表排序，参考十大排序算法，思想是一样的，但是因为是链表不是数组，所以细节上又要多注意些
1.lc147 对链表进行插入排序
描述：
给定单个链表的头 head ，使用 插入排序 对链表进行排序，并返回 排序后链表的头 。
示例：
输入: head = [4,2,1,3] 输出: [1,2,3,4]
Solution：
首先回顾一下插入排序
2.148. 排序链表
链表双指针
1.lc19 删除链表的倒数第 N 个结点
lc19 链接
快慢指针的典型应用！，在 双指针技巧 有介绍
2.lc21 合并两个有序链表
lc21 链接
描述：
将两个升序链表合并为一个新的 升序 链表并返回。
示例：
输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4]
Solution：
双指针的应用！
public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
ListNode dummy = new ListNode();
ListNode p = dummy;
ListNode p1 = list1;
ListNode p2 = list2;
while(p1!=null && p2!=null)
{
if(p1.val<p2.val)
{
p.next = p1;
p1 = p1.next;
}
else
{
p.next = p2;
p2 = p2.next;
}
p = p.next;
}
if(p1==null)
{
p.next = p2;
}
if(p2==null)
{
p.next=p1;
}
return dummy.next;
}
3.lc24 两两交换链表中的节点
lc24 链接
描述：
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。
示例：
输入：head = [1,2,3,4] ； 输出：[2,1,4,3]
Solution：
public ListNode swapPairs(ListNode head) {
ListNode dumyhead = new ListNode(-1,head); // 设置一个虚拟头结点
ListNode cur = dumyhead;
ListNode temp; // 临时节点，保存两个节点后面的节点
ListNode firstnode; // 临时节点，保存两个节点之中的第一个节点
ListNode secondnode; // 临时节点，保存两个节点之中的第二个节点
while (cur.next != null && cur.next.next != null) {
temp = cur.next.next.next;
firstnode = cur.next;
secondnode = cur.next.next;
cur.next = secondnode; // 步骤一
secondnode.next = firstnode; // 步骤二
firstnode.next = temp; // 步骤三
cur = firstnode; // cur移动，准备下一轮交换
}
return dumyhead.next;
}
4.lc234 回文链表
lc234 链接
描述：
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false
示例：
输入：head = [1,2,2,1] ；输出：true
Solution1：
先通过快慢指针找到链表中点，然后反转后半部分，最后与前半部分进行比较.
public boolean isPalindrome(ListNode head) {
// 1.找到链表中点
// 快慢指针，让慢指针指向链表中点
ListNode slow = head, fast = head;
// 注意这里的判断条件
while(fast!=null && fast.next!=null)
{
slow = slow.next;
fast = fast.next.next;
}
// 奇数个数的链表慢指针再移一步
if(fast!=null)
{
slow = slow.next;
}
// 2.开始反转后半部分链表
ListNode cur = slow, pre=null;
while(cur!=null)
{
ListNode tmp = cur.next;
cur.next = pre;
pre = cur;
cur = tmp;
}
// 3.进行比较
while(pre!=null)
{
if(head.val!=pre.val)
return false;
head = head.next;
pre = pre.next;
}
return true;
}
参考链接：
https://leetcode.cn/leetbook/read/linked-list/fpr8s/