LeetCode链表（链表操作，反转链表，奇偶链表，排序链表）_leetcode 链表

前言

本篇文章更注重于链表自身的特点（如果是关于双指针，链表数组字符串中都会出现，所以这里列举几题，更详细的见双指针）

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; }
 }
1
2
3
4
5
6
7
8

（2）双链表

每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。

Java定义：

// Definition for doubly-linked list.
class DoublyListNode {
    int val;
    DoublyListNode next, prev;
    DoublyListNode(int x) {val = x;}
}
1
2
3
4
5
6

（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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

反转链表

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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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;

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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;  
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

参考链接：
https://leetcode.cn/leetbook/read/linked-list/fpr8s/