链表习题复习

最新推荐文章于 2024-07-01 17:36:17 发布
最新推荐文章于 2024-07-01 17:36:17 发布
阅读量198 收藏
点赞数 1
分类专栏： 每日一题 文章标签： 链表 算法 java leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DavenportChen/article/details/117898403
版权

*

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

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

题目描述：

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

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

示例 1:

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

/**
 * 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 == null) return null;
        if(head.val == val){
            return head.next;
        }
        ListNode cur = head;
        while(cur.next.val != val){
            cur = cur.next;
        }
        cur.next = cur.next.next;
        return head;
    }
}

/**
 * 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 && head.next == null){
            return null;
        }
        if(head.val == val && head.next != null){
            head = head.next;
        }
        ListNode cur = head.next;
        ListNode prev = head;
        while(cur != null){
             ListNode curNext = cur.next;
            if(cur.val == val){
                prev.next = cur.next;
                return head;
            }else{
                prev = cur;
                cur = curNext;
            }
        }
        return head;
    }
}

删除链表中的节点

面试题 02.03. 删除中间节点
题目描述:

若链表中的某个节点，既不是链表头节点，也不是链表尾节点，则称其为该链表的「中间节点」。

假定已知链表的某一个中间节点，请实现一种算法，将该节点从链表中删除。

例如，传入节点 c（位于单向链表 a->b->c->d->e->f 中），将其删除后，剩余链表为 a->b->d->e->f

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
         node.val = node.next.val;
        node.next = node.next.next;
    }
}

移除链表元素

203. 移除链表元素

题目描述：

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

示例 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 输出：[]

/**
 * 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 prev = head;
        ListNode cur = head.next;
        while(cur != null){
            if(cur.val == val){
                prev.next = cur.next;
            }else{
                prev = cur;
            }
            cur = cur.next;
        }
        if(head.val == val){
            return head.next;
        }else{
            return head;
        }
    }
}

剑指 Offer 24. 反转链表

剑指 Offer 24. 反转链表
题目描述：

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

示例:

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

/**
 * 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;
        ListNode prev =null;
        ListNode cur = null;
        while(head != null){
            cur = head.next;
            head.next = prev;
            prev = head;
            head = cur;
        }
        return prev;
    }
}

链表的中间结点

876. 链表的中间结点

给定一个头结点为 head 的非空单链表，返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。

/**
 * 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 middleNode(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next!= null){
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }
}

返回倒数第 k 个节点

面试题 02.02. 返回倒数第 k 个节点
题目描述：

实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。

注意：本题相对原题稍作改动

示例：

输入： 1->2->3->4->5 和 k = 2 输出： 4

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int kthToLast(ListNode head, int k) {
        ListNode fast = head;
        ListNode slow = head;

        while(k-1 != 0){
            fast = fast.next;
            k--;
        }
        while(fast.next != null){  
            fast = fast.next;
            slow = slow.next;
        }
        return slow.val;
    }
}

合并两个排序的链表

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

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

示例1： 输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

/**
 * 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) {
        if(l1 == null){
            return l2;
        }
        if(l2 == null){
            return l1;
        }
        ListNode list = new ListNode(0);
        ListNode cur = list;
        while(l1 != null && l2 != null){
            if(l1.val <= l2.val){
                cur.next = l1;
                l1 = l1.next;
            }else{
                cur.next = l2;
                l2 = l2.next;
            }
            cur = cur.next;
        }
        if(l1 != null){
            cur.next = l1;
        }else{
            cur.next = l2;
        }
        //cur.next = (l1 != null) ? l1:l2;
        return list.next;
    }
}

链表分割

链表分割
题目描述：

现有一链表的头指针 ListNode*
pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。

import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        // write code here
        if(pHead == null || pHead.next == null) return pHead;
        ListNode h1 = new ListNode(0);
        ListNode h2 = new ListNode(0);
        ListNode cur1 = h1;
        ListNode cur2 = h2;
        while(pHead != null){
            if(pHead.val < x){
                cur1.next = new ListNode(pHead.val);
                cur1 = cur1.next;
            }else{
                cur2.next = new ListNode(pHead.val);
                cur2 = cur2.next;
            }
            pHead = pHead.next;
        }
        cur1.next = h2.next;
        return h1.next;
    }
}

删除链表中重复的结点

删除链表中重复的结点
题目描述：

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。
例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

示例1 输入 {1,2,3,3,4,4,5} 输出 {1,2,5}

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead) {
        if(pHead == null || pHead.next == null)return pHead;
        ListNode head = new ListNode(0);
        head.next = pHead;
        ListNode prev = head;
        ListNode cur = head.next;;
        while(cur != null){
            if(cur.next != null && cur.val == cur.next.val){
                while(cur.next != null && cur.val == cur.next.val){
                    cur = cur.next;
                }
                prev.next = cur.next;
                cur = cur.next;
            }else{
                prev = cur;
                cur = cur.next;
            }
        }
        return head.next;
    }
}

链表的回文结构

链表的回文结构
题目描述：

对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。
给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。

测试样例： 1->2->2->1 返回：true

import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class PalindromeList {
    public boolean chkPalindrome(ListNode A) {
        // write code here
        Stack<Integer> stack = new Stack<>();
        ListNode cur = A;
        while(cur != null){
            stack.push(cur.val);
            cur = cur.next;
        }
        while(!stack.isEmpty()){
            if(stack.pop() == A.val){
                 A = A.next;
            }else{
                return false;
            }
        }
        return true;
    }
}


import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class PalindromeList {
    public boolean chkPalindrome(ListNode A) {
        // write code here
        if(A == null) return false;
        ListNode fast = A;
        ListNode slow = A;
        //找到链表中间节点
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
        }
        //反转链表后半部分
        ListNode cur = slow.next;
        while(cur != null){
            ListNode curNext = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curNext;
        }
        //从头往中间 从后往中间依次比较是否相同
        //只要A.val != slow.val 则返回false; 如果链表长度为偶数，则当A.next== slow时 说明相遇 即返回true
        while(A != slow){
            if(A.val != slow.val){
                return false;
            }
            if(A.next == slow){//偶数情况
                return true;
            }
            A = A.next;
            slow = slow.next;
        }
        return true;
    }
}

剑指 Offer 52. 两个链表的第一个公共节点

两个链表的第一个公共节点
题目描述：
在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode A = headA;
        ListNode B = headB;
        while(A != B){//若没有交集则A==B==null退出循环
            A = (A != null ? A.next : headB);
            B = (B != null ? B.next : headA);
        }
        return A;
    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
         if(headA == null || headB == null){
            return null;
        }
        int lenA = 0;
        int lenB = 0;
        ListNode pl = headA;
        ListNode ps = headB;
        while(pl != null){
            pl = pl.next;
            lenA++;
        }
        while(ps != null){
            ps = ps.next;
            lenB++;
        }
        pl = headA;
        ps = headB;
        int len = lenA - lenB;
        if(len < 0) {
            pl = headB;//pl指向较长的链表
            ps = headA;//ps指向较短的链表
            len = lenB - lenA;
        }
        while(len != 0){
            pl = pl.next;
            len--;
        }
        while(pl != ps){
            pl = pl.next;
            ps = ps.next;
        }
        return pl;  
        }
}

判断链表是否有环

环形链表
给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
如果链表中存在环，则返回 true 。 否则，返回 false 。

解法1：利用HashSet

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null) return false;
        HashSet<ListNode> set = new HashSet<>();
        ListNode cur = head;
        while(cur != null) {
            if(set.contains(cur)) {
                return true;
            }
            set.add(cur);
            cur = cur.next;
        }
        return false;
    }
}

解法2：快慢指针

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null)return false;
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (slow == fast)
                return true;
        }
        return false;
    }
}

返回链表入环的第一个节点

环形链表 II
题目描述：

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

解法1：

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode cur = head;
        Set<ListNode> set = new HashSet<ListNode>();
        while (cur != null) {
            if (set.contains(cur)) {
                return cur;
            } else {
                set.add(cur);
            }
            cur = cur.next;
        }
        return null;
    }
}

解法2：

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
         if (head == null)return null;
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (slow == fast)
                break;;
        }
        if(fast == null || fast.next == null){
            return null;
        }
        slow = head;
        while(fast != slow){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}
DavenPortChen.
关注
专栏目录
专转本计算机复习习题.zip
09-22
这个压缩包包含的资源，很可能是为准备这类考试的学生设计的一系列练习题。 习题集通常涵盖了计算机科学的基础知识，可能包括以下几个核心领域： 1. **计算机基础**：这部分可能涉及计算机硬件、软件、操作系统的...
链表经典 10题
mu_tong_的博客
10-12 2485
链表10 道经典例题
【数据结构与算法-链表经典例题汇总】
是小武呀
03-01 1940
【数据结构与算法-链表经典例题汇总】典例1、链表逆序-a（easy）典例1、链表逆序-b（medium）典例2、求两个链表的交点-（easy）典例3、链表求环 - （medium）典例4、链表划分- (medium)典例5、复杂链表的深度拷贝 - (hard)典例6、排序链表的合并a-两个（easy）典例6、排序链表的合并b-多个（hard） 典例1、链表逆序-a（easy） 题目描述： 思路：依次遍历链表的节点，每遍历一个节点就逆置一个节点 。 LeetCode提交OJ测试链接: OJ
“手撕“9道经典链表算法题
最新发布
ha2042894194的博客
07-01 949
在学完单链表（单向不带头不循环）和双向链表(双向带头循环)后我们会发现双向链表虽然结构略微复杂，但实现相同功能时相较于单链表方便了不止一星半点。
【数据结构】详解11道链表OJ题（万字详解）
丨归凡的博客
08-11 915
万字详解11道链表OJ题，图文并茂，一题多解。
【数据结构】链表经典练习题
Dooo_yh的博客
01-01 4678
1.移除单链表元素 2.逆转单链表 3.获取链表的中间结点 4.获取链表中倒数第k个结点 5.合并两个有序单链表 6.单链表一分为二 7.判断链表是否为回文结构
六道链表经典算法题，带你体验链表算法魅力
2301_80157147的博客
02-08 1184
给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点这道题读完题目的话很多人的思路是遍历链表，根据节点个数，然后返回中间节点但今天我们讲的思路称之为快慢指针既然是快慢指针，那么一定有两个指针，并且两个指针的前进速度也不相同所以在这里，快指针一次前进两个节点，慢指针一次前进一个节点这样的话，当节点是奇数时，快指针的next指向NULL时，慢指针刚好在中间位置当节点是偶数是，当快指针指向为NULL时，慢指针也在第二个中间节点这样代码就完成了。
数据结构分章练习题和复习纲要
09-04
本资料集合包含“数据结构分章练习题”和“复习纲要”，是针对这门课程的重要学习资源。 1. **数据结构基础** 数据结构是编程的基础，包括线性结构（如数组、链表）、树形结构（如二叉树、堆）、图结构以及特殊的...
C++ PTA习题总结 期末复习
06-29
在准备C++ PTA（Programming Training ...总之，C++ PTA习题的复习不应仅停留在理论层面，而应结合实际编程练习，将理论知识转化为实际技能。通过系统的复习和大量的练习，相信你可以在期末考试中取得理想的成绩。
数据结构复习题C语言
06-24
在练习题中，第一题考查了数据结构的分类，答案是C，线性结构和非线性结构。第二题考察了数据的逻辑结构，答案是C，逻辑结构。第三题询问非线性结构的例子，答案是A，树。第四题分析了算法的时间复杂度，第一个是...
数据结构期末练习题.doc
08-31
以下是对给定练习题中涉及知识点的详细解释： 1. **数据元素**：数据的不可分割的基本单位是元素（A），在计算机程序中，元素是最基本的数据单元。 2. **数据项**：计算机处理数据的最小单位是数据项（D），它是...
链表相关练习题以及题解
2302_81342533的博客
05-01 984
学习完了链表结构，不妨多加练习熟系这种数据结构。所以本篇论文列举出了一些和链表相关的练习题，并描述解题思路，相信对能够令读者对链表这种结构的掌握更加得心应手。
链表经典练习题
2302_81016149的博客
05-01 779
本篇文章到这里就结束了，如果有不理解的题目，可私信或在评论区留下问题，记得一定要练习，这是非常重要的。再强调：大部分题目解法只为了抛砖引玉。希望对大家有所启发。完！
数据结构之链表练习题(leetCode）
容铎的博客
05-01 1781
数据结构之链表练习题(leetCode）
链表的经典习题（画图详解）
weixin_69939913的博客
11-10 678
链表的经典习题
Leetcode：链表刷题（7道经典题目）
一起加油~
03-22 1735
Leetcode：链表刷题 列出了一些关于链表的经典题目，并提供了对应的题解。主要是用C++实现的。对于使用其他语言的童鞋，可以很好的迁移过去。
单链表基础实现+单双链表数组模拟+STL使用+习题练习（超详解）
2302_79366101的博客
11-04 216
链表由一系列节点（链表中每一个元素称为节点）组成，节点在运行时动态生成 （malloc），每个节点包括两个部分：一个是存储数据元素的数据域data另一个是存储下一个节点地址的指针域next*
【初阶数据结构】链表经典OJ（8道）
2401_82610555的博客
05-16 1012
2.首先当链表节点个数为奇数时，中间节点有两个，我们需要返回下一个中间节点，这种情况下，快慢指针也可以解决，当slow指针走到前一个中间节点时，fast才走到尾节点的前一个节点，但是需要注意的是，当slow走到下一个中间节点时，fast会走到尾节点的下一个指针，即fast会变成空指针，我们根据fast为空结束循环，直接返回slow。新链表的random指向不是指向原链表中的节点，而是新的节点，得到的新链表与原链表出指针指向的空间不同，其他的val值，指针指向的相对位置关系都一致。笔者接下来论证一下。
C++指针与链表基础复习及习题解析
"C++指针和链表复习题，包含选择题，涉及指针操作、数组、字符串、内存管理及函数参数等知识点。" 详细解释： 1. 指针与字符数组： - 选项A：声明了一个字符引用a，将其绑定到*p所指向的字符。 - 选项B：错误，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值