LeetCode篇（面试中常见 链表题 详解）

最新推荐文章于 2022-12-30 13:02:16 发布
最新推荐文章于 2022-12-30 13:02:16 发布
阅读量321 收藏 7
点赞数
分类专栏： LeetCode刷题篇 文章标签： java 链表 算法 数据结构 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44638376/article/details/113919560
版权

1、附上题目链接

2、代码关键点详解

2.1 关键点：翻转链表

2.1.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) {
        ListNode pre = null;
        ListNode next = null;
        while (head != null) {
            next = head.next; //临时节点，暂存当前节点的下一节点，用于后移
            head.next = pre; //将当前节点指向它前面的节点
            pre = head; //前指针后移
            head = next; //当前指针后移
        }
        return pre;
    }


    /**************** 递归 *****************/
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) return head;

        ListNode next = head.next; // 保存当前节点的下一节点
        ListNode reverseHead = reverseList(next); // 翻转剩下部分
        next.next = head; //将翻转后的结果 和 第一个节点相连接
        head.next = null; //断链
        return reverseHead;
    }
}

关键点1：迭代

  • 注意：这个代码递归和迭代方式都很简单，但是要记住迭代方式的算法代码，因为在其他算法题中经常用得到。

2.1.2 翻转链表 II

class Solution {
    public ListNode reverseBetween(ListNode head, int m, int n) {
        ListNode res = new ListNode(0);
        res.next = head;
        ListNode node = res;
        //找到需要反转的那一段的上一个节点。
        for (int i = 1; i < m; i++) {
            node = node.next;
        }
        //node.next就是需要反转的这段的起点。
        ListNode nextHead = node.next;
        ListNode next = null;
        ListNode pre = null;
        //反转m到n这一段
        for (int i = m; i <= n; i++) { // <= n !!!!!!!!!!
            next = nextHead.next;
            nextHead.next = pre;
            pre = nextHead;
            nextHead = next;
        }
        //将反转的起点的next指向next。
        node.next.next = next; // !!!!!!!!!!!!!
        //需要反转的那一段的上一个节点的next节点指向反转后链表的头结点
        node.next = pre;  // !!!!!!!!!!!!!
        return res.next;
    }
}

关键点1：翻转流程

  1. 找到需要反转的那一段的上一个节点
  2. 反转m到n这一段 for (int i = m; i <= n; i++)
  3. 将反转的起点的next指向next node.next.next = next; // !!!!!!!!!!!!!
  4. 需要反转的那一段的上一个节点的next节点指向反转后链表的头结点 node.next = pre; // !!!!!!!!!!!!!

2.1.3 K 个一组翻转链表

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null) return head;
        ListNode l1 = head, l2 = head;
        // 区间 [l1, l2) 包含 k 个待反转元素
        for (int i = 0; i < k; i++) {
            // 不足 k 个，不需要反转，base case
            if (l2 == null) return head;
            l2 = l2.next;
        }
        // 反转前 k 个元素
        ListNode newHead = reverse(l1, l2);
        // 递归反转后续链表并连接起来
        l1.next = reverseKGroup(l2, k);
        return newHead;
    }

    /** 反转区间 [l1, l2) 的元素，注意是左闭右开 */
    public ListNode reverse(ListNode l1, ListNode l2) {
        ListNode cur = l1;
        ListNode pre = null, next = null;
        while (cur != l2) {
            next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next; 
        }
        return pre;
    }
}

关键点1：每 k 个节点一组进行翻转

ListNode l1 = head, l2 = head;
for (int i = 0; i < k; i++) {
	if (l2 == null) return l1;
	l2 = l2.next;
}

2.2 关键点：快慢指针

2.2.1 旋转链表

class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        // base case
        if (head == null || head.next == null || k <= 0) return head;

        // 链表长度 和 链表尾指针
        int len = 0;
        ListNode tail = head;
        while (tail != null && tail.next != null) { // tail.next != null 保证尾指针不为null !!!!!
            len++;
            tail = tail.next;
        }
        len++;

        // 链表旋转
        ListNode first = head, second = head;
        k = k % len;
        if (k == 0) return head; // 不用旋转
        while (k > 0) { // k > 0 保证快指针找到旋转节点的前一个位置
            first = first.next;
            k--;
        }
        while (first != null && first.next != null) { // first.next != null 保证快指针找到旋转节点的前一个位置
            first = first.next;
            second = second.next;
        }

        ListNode secondHead = second.next; // 后半部分头结点
        second.next = null; // 前半部分 和 后半部分断开
        tail.next = head; // 将第二部分的尾 和 第一部分的头相连

        return secondHead; 
    }
}

关键点1：k值

  • 由于本题没有注明 k 值得范围，而且根据 示例 可以看出，当 k 值大于链表长度时，采用对链表长度取模的方式进行旋转k = k % len;。

关键点2：旋转

  • 对于该题，采用快慢指针的方法进行旋转，先通过快指针找到旋转节点的前一个位置，然后以旋转点为头，将前后链表断开，并将链表的尾指针指向头指针即可

关键点3：快慢指针

  • 将快指针和慢指针均初始化为同一节点（如：ListNode first = head, second = head;）

2.2.2 删除链表的倒数第 N 个结点

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        /* 双指针 + 伪头节点 推荐 */

        if (head == null || n <= 0) return head;

        ListNode pre = new ListNode(0); //伪头结点
        pre.next = head;
        ListNode fast = pre, slow = pre; //维护两个双指针，将指针指向pre。若指向head，而我们恰好要删除head，会出现异常

        while (n > 0) {
            // if (fast.next == null) return head.next; // 注意！！！！！！！
            if (fast == null) return head.next; // 注意！！！！！！！

            fast = fast.next; //将第一个指针先向前移动 n 步
            n--;
        }

        while (fast != null && fast.next != null) { // 注意 fast.next != null ！！！！！！！
            slow = slow.next; // 同时移动快慢指针，直到快指针指向null
            fast = fast.next;
        }

        if (slow != null && slow.next != null) {
            slow.next = slow.next.next;
        }

        return pre.next;
    }
}

关键点1：伪头结点

  • 为了防止删除的头结点，无法返回头指针，所以我们提前设置一个伪头结点 ListNode pre = new ListNode(0); //伪头结点 pre.next = head;。

关键点2：当删除节点长度大于等于链表长度时

  • 对于该题，当删除节点长度大于等于链表长度时，都是删除的头结点。if (fast == null) return head.next;

关键点3：待删除节点查询

  • 该题采用快慢指针找待删除节点的方式和上一题相同，都是先找到待删除节点的上一个节点指针

2.3 关键点：有序链表合并

2.3.1 合并K个升序链表

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if(lists == null || lists.length == 0) return null; // 边界条件
        return merge(lists, 0, lists.length - 1);
    }

    //归并
    private ListNode merge(ListNode[] lists, int left, int right) {
        // 停止条件
        if(left == right) return lists[left];

        //归并
        int mid = left + (right - left) / 2;
        ListNode l1 = merge(lists, left, mid);
        ListNode l2 = merge(lists, mid + 1, right);

        return mergeTwoLists(l1, l2);  
    } 

    //原地合并两个链表 ！！！！！
    private ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        // 停止条件
        if(l1 == null) return l2;
        if(l2 == null) return l1;

        // 递归
        if(l1.val < l2.val){
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

关键点1：合并两个有序链表

  • 采用递归的方式原地合并两个有序链表，代码很重要哟，记不住就背过吧

2.4 关键点：找到链表中点

2.4.1 链表的中间结点

  • 代码略

关键点1：找到链表中点

  • 链表长度为奇数时，slow 为中间节点指针
  • 链表长度为偶数时，slow 为中间偏左节点指针
public ListNode middleNode(ListNode head) {
    ListNode fast = head.next;
	ListNode slow = head;
	while (fast != null && fast.next != null) {
	    fast = fast.next.next;
	    slow = slow.next;
	}
    return slow;
}
  • 链表长度为奇数时，slow 为中间节点指针
  • 链表长度为偶数时，slow 为中间偏右节点指针
public ListNode middleNode(ListNode head) {
    ListNode fast = head, slow = head;
    while (fast != null && fast.next != null) {
        fast = fast.next.next;
        slow = slow.next;
    }
    return slow;
}

2.5 关键点：链表复制

2.5.1 复制带随机指针的链表

/*
// Definition for a Node.
class Node {
    int val;
    Node next;
    Node random;

    public Node(int val) {
        this.val = val;
        this.next = null;
        this.random = null;
    }
}
*/

class Solution {
    public Node copyRandomList(Node head) {
        if (head == null) return head;

        Node cur = head, copyCur = null, next = null; // 当前指针，复制链表当前指针，当前节点下一个节点指针
        
        // 复制next指针 1 - 1' - 2 - 2'
        while (cur != null) {
            // 当前节点下一个节点指针
            next = cur.next;

            copyCur = new Node(cur.val);

            // 将当前节点和拷贝节点连接
            cur.next = copyCur;
            copyCur.next = next;

            // 更新
            cur = next;
        }

        // 复制随机指针
        cur = head;
        while (cur != null) {
            cur.next.random = cur.random != null ? cur.random.next : null;
            cur = cur.next.next;
        }

        // 拆开
        Node copyHead = null;
        cur = head; copyCur = null; next = null;
        while (cur != null) {
            // 当前节点下一个节点指针
            next = cur.next.next;

            if (copyHead == null) {
                copyHead = cur.next;
                copyCur = copyHead;
            } else {
                copyCur.next = cur.next;
                copyCur = copyCur.next;
            }

            cur.next = next;
            cur = cur.next;
        }
        return copyHead;
    }
}

关键点1：next 节点复制

  • 复制next指针，将复制节点连接在当前节点后边，形成这种格式 1 - 1’ - 2 - 2’ - null

关键点2：random 节点复制

  • 复制随机指针 cur.next.random = cur.random != null ? cur.random.next : null;

2.6 关键点：链表排序

2.6.1 对链表进行插入排序

class Solution {
    public ListNode insertionSortList(ListNode head) {
        if (head == null) return head;

        ListNode res = new ListNode(Integer.MIN_VALUE);
        res.next = head;

        ListNode sortTail = head;  // 已排序部分尾指针
        ListNode cur = head.next; // 当前指针
        ListNode pre = res; // 待插入位置的前指针

        while (cur != null) {
            if (cur.val >= sortTail.val) {
                cur = cur.next;
                sortTail = sortTail.next;
            } else {
                pre = res;
                // 找到 pre.val < cur.val <= pre.next.val 的点
                while (pre != sortTail && pre.next.val < cur.val) {
                    pre = pre.next;
                }

                sortTail.next = cur.next; // 直接将已排序好的尾指针指向当前指针下一节点
                cur.next = pre.next;
                pre.next = cur;
                cur = sortTail.next;
            }
        }
        return res.next;
    }
}

关键点1：维护一个待插入位置的前指针 和 已排序链表的尾指针

  • ListNode sortTail = head; // 已排序部分尾指针
  • ListNode pre = res; // 待插入位置的前指针

2.6.2 排序链表

class Solution {
    /******************* 归并排序 自顶向下*********************/
    // public ListNode sortList(ListNode head) {
    //     if (head == null || head.next == null) return head; //边界条件

    //     // 链表断开
    //     ListNode fast = head.next, slow = head;
    //     while (fast != null && fast.next != null) {
    //         fast = fast.next.next;
    //         slow = slow.next;
    //     }
    //     ListNode temp = slow.next; //第二部分链表头 如：123-45、123-456
    //     slow.next = null; //第一部分链表

    //     // 链表排序
    //     ListNode left = sortList(head); //第一部分链表排序
    //     ListNode right = sortList(temp); //第二部分链表排序

    //     // 链表合并
    //     return merge(left, right);
    // }

    // /* 合并两个有序链表 */
    // public ListNode merge(ListNode l1, ListNode l2){
    //     if (l1 == null) return l2;
    //     if (l2 == null) return l1;

    //     if (l1.val < l2.val) {
    //         l1.next = merge(l1.next, l2);
    //         return l1;
    //     } else {
    //         l2.next = merge(l1, l2.next);
    //         return l2;
    //     }
    // }

    /******************* 归并排序 自底向上*********************/
    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null) return head;

        int len = getListNodeLen(head); // 统计链表长度
        ListNode res = new ListNode(0); res.next = head;
        int itrv = 1;
        while (itrv < len) {
            ListNode curRes = res, cur = res.next; // cur = res.next 注意不要写成 head ！！！

            // 1. 找到合并链表的 l1 和 l2 头节点
            while (cur != null) {
                ListNode l1= cur;

                // 1.1 找到合并链表的 l1 头节点
                int loop = itrv;
                while (cur != null && loop > 0) {
                    cur = cur.next;
                    loop--;
                }
                if (loop > 0) break; // 无 l2
                // 1.2 找到合并链表的 l1 头节点
                ListNode l2 = cur;
                loop = itrv;
                while (cur != null && loop > 0) {
                    cur = cur.next;
                    loop--;
                }

                // 2. 合并
                int len1 = itrv, len2 = itrv - loop;
                while (len1 > 0 && len2 > 0) {
                    if (l1.val < l2.val) {
                        curRes.next = l1;
                        l1 = l1.next;
                        len1--;
                    } else {
                        curRes.next = l2;
                        l2 = l2.next;
                        len2--;
                    }
                    curRes = curRes.next;
                }

                l1 = len1 > 0 ? l1 : l2;
                len1 = len1 > 0 ? len1 : len2;
                while (len1 > 0) {
                    curRes.next = l1;
                    l1 = l1.next;
                    curRes = curRes.next;
                    len1--;
                }

                curRes.next = cur; // 3. 和下一段链表拼接上
            }
            itrv *= 2;
        }
        return res.next;
    }

    // 统计链表长度
    private int getListNodeLen(ListNode head) {
        ListNode cur = head;
        int len = 0;
        while (cur != null) {
            len++;
            cur = cur.next;
        }
        return len;
    }
}

关键点1：归并排序

  • 自上向下：空间复杂度（n）
  • 自下向上：空间复杂度（1）
萌萌哒小草莓
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode：链表刷题（7道经典题目）
一起加油~
03-22 1604
Leetcode：链表刷题 列出了一些关于链表的经典题目，并提供了对应的题解。主要是用C++实现的。对于使用其他语言的童鞋，可以很好的迁移过去。
LeetCode算法之--链表系列
程序大视界
12-21 699
LeetCode链表常见算法题型
链表的经典习题（画图详解）
weixin_69939913的博客
11-10 483
链表的经典习题
经典链表--题型详解
！
04-04 1569
链表基础题，常见常用的几种思路
【字符串】彩色珠宝项链问题
sinat_38972110的博客
04-19 352
题目：有一条彩色宝石项链，是由很多种不同的宝石组成的，包括红宝石，蓝宝石，钻石，翡翠，珍珠等。有一天国王把项链赏赐给了一个学者，并跟他说，你可以带走这条项链，但是王后很喜欢红宝石，蓝宝石，紫水晶，翡翠和钻石这五种，我要你从项链中截取连续的一小段还给我，这一段中必须包含所有的这五种宝石，剩下的部分你可以带走。如果无法找到则一个也无法带走。请帮助学者找出如何切分项链才能够拿到最多的宝石。  ...
Leetcode以及一些常见的面试题，刷题详解，透彻解析
最新发布
05-26
Leetcode以及一些常见的面试题，刷题详解，透彻解析。适用人群：计算机，软件工程等专业的大学生，找工作，找实习，提升能力，作为练习使用，高分通过OJ测试。 Leetcode以及一些常见的面试题，刷题详解，透彻解析。...
python-leetcode面试题解之第92题反转链表II.zip
04-23
python python_leetcode面试题解之第92题反转链表II
python-leetcode面试题解之删除链表的倒数第N个节点.zip
03-06
python python_leetcode面试题解之删除链表的倒数第N个节点
python-leetcode面试题解之第160题相交链表-题解.zip
05-21
python python_leetcode面试题解之第160题相交链表_题解
python-leetcode面试题解之第148题排序链表-题解.zip
05-14
python python_leetcode面试题解之第148题排序链表_题解
LeetCode链表经典题目（二）
m0_60750183的博客
12-30 870
LeetCode链表经典题目（二）
数据结构之链表练习题(leetCode）
容铎的博客
05-01 1684
数据结构之链表练习题(leetCode）
leetcode链表面试题目集锦
热门推荐
xiangxianghehe的博客
08-16 1万+
本文系转载,出处信息 作者：Mr希灵 链接：https://www.jianshu.com/p/f0c3235369ac 來源：简书 1.链表 链表是最基本的数据结构，面试官也常常用链表来考察面试者的基本能力，而且链表相关的操作相对而言比较简单，也适合考察写代码的能力。链表的操作也离不开指针，指针又很容易导致出错。综合多方面的原因，链表题目在面试中占据着很重要的地位。 1.1定义 链...
将单向链表按某值划分成左边小，中间相等，右边大的形式
qq_38314385的博客
06-15 253
代码 package class_03; import java.util.Stack; public class Code_11_IsPalindromeList { public static class Node { public int value; public Node next; public Node(int d...
Leetcode刷题笔记之: 链表（单链表经典题目）
weixin_42267196的博客
11-16 306
这里写目录标题206. 反转链表迭代算法:递归算法[203. 移除链表元素](https://leetcode-cn.com/problems/remove-linked-list-elements/)[328. 奇偶链表](https://leetcode-cn.com/problems/odd-even-linked-list/)[234. 回文链表](https://leetcode-cn.com/problems/palindrome-linked-list/)总结 206. 反转链表 迭代算法
链表详解 （详细举例）
Liquor___的博客
03-31 1047
链表详解 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。 链表有一个 头指针 变量，它存放一个地址，该地址指向一个元素，链表中每一个元素称为 结点，每个结点都应包括两个部分，一为用户需要用的实际数据，二为下一个结点的地址。可以看出，头指针 head 指向第一个元素，第一个元素又指向第二个元素，。。。。直到最后一个元素，该元素不再指向其他元素，它称为 表尾，它的地址部分放一个 N...
链表笔试面试题（一）
xiongluo0628的博客
08-02 1291
本博客内容 1、单链表的结构 2、求链表的长度 3、单链表反转 4、单链表倒数第k个节点 5、查找链表的中间节点 6、从尾到头打印链表 7、已知2个单链表有序，把它们合并为一个有序链表 8、判断一个单链表是否有环 9、判断2个链表是否相交 10、求2个单链表相交的第1个节点 1、单链表的结构 struct ListNode { int m_nValue...
算法——高频题
powerful_ren的博客
03-15 339
桶 用数组结构实现大小固定的队列和栈 队列：先进先出 假设固定大小为len，size为当前队列大小，start表示队头，end表示队尾。 若size<0 或 size>len, 则越界。 出队，end+1位置覆盖一个数。size++; 若end到达数组尾部，则end 返回到数组首部；否则end++ 入队，start 位置减去一个数。start–; size– 栈：先进后出 假设固定...
数组、字符串、链表、树面试题汇总
nanjunxiao的专栏
06-26 2258
数组 1.      如何用递归实现数组求和 2.      如何用一个for打印出一个二维数组 A[count/col][count%col] 3.      在顺序表中插入和删除一个节点平均移动多少个节点 插入：（0+n）/2 删除：（0+n-1）/2 4.      如何用递归算法判断一个数组是否是递增？ Bool up(int a[],int beg,int end) {
leetcode-5:实现链表的首尾链接
12-30
leetcode-5题要求我们实现链表的首尾链接，即将链表中最后一个节点的next指针指向链表中的第一个节点，并将链表中的第一个节点的prev指针指向链表中最后一个节点。 解题思路如下： 1. 首先，判断链表是否为空，若为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值