代码随想录算法训练营第四天|24. 两两交换链表中的节点、19. 删除链表的倒数第 N 个结点、面试题 02.07. 链表相交、142. 环形链表 II

已于 2024-06-08 17:50:44 修改
阅读量1k 收藏 30
点赞数 25
文章标签： 算法 链表 数据结构
于 2024-06-08 17:48:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79744698/article/details/139546033
版权

目录

24. 两两交换链表中的节点

题目链接：

题目要求：

题目用例：

实现思路：

实现代码：

测试代码：

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

题目链接：

题目要求：

题目用例：

实现思路：

实现代码：

测试代码：

面试题 02.07. 链表相交

题目链接：

题目要求：

题目用例：

实现思路：

实现代码：

 142. 环形链表 II

题目链接：

题目要求：

题目用例：

实现思路：

实现代码：

24. 两两交换链表中的节点

题目链接：

24. 两两交换链表中的节点 - 力扣（LeetCode）

题目要求：

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

题目用例：

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

实现思路：

1.定义虚拟头指针（dummyHead）指向head，定义临时指针（temp）用来保存节点值，

初始化当前指针（current）位置指向虚拟头指针

2.循环条件为链表中至少要有两个值

3.用临时指针保存下一个节点值，在让下一个节点值赋值为下下个节点值，移动指针到下下个节点，把当前节点值赋值为临时指针中存储的值

4.返回头指针(dummyHead.next)

实现代码：

class Solution {
    //给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
    //定义虚拟头结点
   private ListNode dummyHead = new ListNode(0);
    public ListNode swapPairs(ListNode head) {
        //指向head
        dummyHead.next=head;
        //当前指针位置
        ListNode current = dummyHead;
        //定义临时存储节点值
        ListNode temp = dummyHead;
        //循环遍历
        while (current.next != null&&current.next.next != null) {
            //保存下个节点值
            temp.val=current.next.val;
            //为下个节点赋值
            current.next.val=current.next.next.val;
            //移动指针两次
            current=current.next.next;
            //为当前节点赋值
            current.val=temp.val;
        }
        return dummyHead.next;

    }
}

测试代码：

public class Test {
/*
    示例 1：
    输入：head = [1,2,3,4]
    输出：[2,1,4,3]

    示例 2：
    输入：head = []
    输出：[]

    示例 3：
    输入：head = [1]
    输出：[1]
*/

    public static void main(String[] args) {
        Solution solution = new Solution();

        //示例1：
        ListNode head1 = new ListNode(1);
        head1.next = new ListNode(2);
        head1.next.next = new ListNode(3);
        head1.next.next.next = new ListNode(4);
        printList(solution.swapPairs(head1));

        //示例2：
        ListNode head2 = null;
        printList(solution.swapPairs(head2));


        //示例3：
        ListNode head3 = new ListNode(1);
        printList(solution.swapPairs(head3));

    }
    public static void printList(ListNode head){
        ListNode cur = head;
        while(cur != null){
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }
}

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

题目链接：

19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

题目要求：

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

题目用例：

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[1]

实现思路：

1.定义虚拟头指针（dummyHead），指向头结点

2.定义两个当前指针（curr1和curr2）为位置，一个用来获取链表长度（size），另一个用来在输入的n合理的情况下，找到要删除的数的上一个位置

3.进入循环，得到链表长度

4.判断n是否合理,由于题目提示n的范围为非负数，所以可以不写n<0的情况

如果n不合理，直接返回原链表；如果n合理，进入循环让size--，找到要删除的前一个节点，让其指向下下个节点，跳过要删除的节点

5.返回头指针(dummyHead.next)

实现代码：

class Solution {
    //给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
    //定义虚拟头节点
    ListNode dummyHead = new ListNode(0);
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //让虚拟头节点指向头结点
        dummyHead.next = head;
        //定义当前指针位置
        ListNode curr1 = dummyHead;
        ListNode curr2 = dummyHead;
        //定义链表长度
        int size = 0;
        //遍历链表,获取链表长度
        while (curr1.next != null) {
            curr1 = curr1.next;
            size++;
        }
        //如果要删除的数大于链表的长度，直接返回原链表
        if (size<n){
            return dummyHead.next;
        }else {
            while (curr2.next != null&&size>=n+1){
                curr2 = curr2.next;
                size--;
            }
            curr2.next = curr2.next.next;
        }
        return dummyHead.next;

    }
}

测试代码：

public class Test {
/*
    示例 1：
    输入：head = [1,2,3,4,5], n = 2
    输出：[1,2,3,5]

    示例 2：
    输入：head = [1], n = 1
    输出：[]

    示例 3：
    输入：head = [1,2], n = 1
    输出：[1]*/
    public static void main(String[] args) {
        Solution solution = new Solution();

        //示例1：
        ListNode head1=new ListNode(1);
        head1.next=new ListNode(2);
        head1.next.next=new ListNode(3);
        head1.next.next.next=new ListNode(4);
        head1.next.next.next.next=new ListNode(5);
        printList(solution.removeNthFromEnd(head1,2));

        //示例2：
        ListNode head2=new ListNode(1);
        printList(solution.removeNthFromEnd(head2,1));

        //示例3：
        ListNode head3=new ListNode(1);
        head3.next=new ListNode(2);
        printList(solution.removeNthFromEnd(head3,1));
    }
    public static void printList(ListNode head){
        ListNode cur = head;
        while(cur != null){
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

}

面试题 02.07. 链表相交

题目链接：

面试题 02.07. 链表相交 - 力扣（LeetCode）

题目要求：

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

题目用例：

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

实现思路：

1.判断链表其中一个是否为空，存在一个空的都不可能会相交

2.定义两个指针(currentA和currentB)指向头指针,定义两个链表的长度（sizeA=1和sizeB=1）

3.分别进入循环，找到两个链表的长度

4.获取两个链表长度的差值（cha）

5.定义临时指针（tempA和tempB），让长的链表先走cha步

6.同时遍历两个链表，遇到相等的直接返回临时指针所在的节点，否则返回null

实现代码：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 如果其中一个链表为空，则没有相交节点
        if (headA == null || headB == null) {
            return null;
        }

        // 获取链表A的长度
        int sizeA = 1;
        ListNode currentA = headA;
        while (currentA.next != null) {
            currentA = currentA.next;
            sizeA++;
        }

        // 获取链表B的长度
        int sizeB = 1;
        ListNode currentB = headB;
        while (currentB.next != null) {
            currentB = currentB.next;
            sizeB++;
        }

        // 获取两个链表长度的差值
        int cha = sizeA > sizeB ? sizeA - sizeB : sizeB - sizeA;

        //定义临时指针
        ListNode tmpA = headA;
        ListNode tmpB = headB;
        if (sizeA < sizeB) {
            //交换两个临时指针
            tmpA = headB;
            tmpB = headA;
        }
        // 让长的链表先走cha步
        for (int i = 0; i < cha; i++) {
            tmpA = tmpA.next;
        }
        // 同时遍历两个链表，直到找到相交的节点或者遍历到链表的末尾
        while (tmpA != null) {
            if (tmpA == tmpB) {
                return tmpA;
            }
            tmpA = tmpA.next;
            tmpB = tmpB.next;
        }
        // 没有找到相交的节点
        return null;
    }
}

 142. 环形链表 II

题目链接：

142. 环形链表 II - 力扣（LeetCode）

题目要求：

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

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

不允许修改 链表。

题目用例：

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

实现思路：

1.判断是否有两个数据，没有直接返回null

2.定义快慢指针（fast和slow）指向头指针

3.寻找快慢指针相遇点，循环条件以fast.next != null&&fast.next.next != null为true进入循环，快指针一次移动两格。慢指针一次移动一格（由于相对运动快指针相对慢指针永远在移动一格，所以二者终会相遇），当二者相遇时结束循环

4.判定无环情况：fast==null||fast.next==null||fast.next.next==null

5.让slow指针重新指向头指针，二者开始循环移动一格，直到二者相遇

6.返回快指针或慢指针

实现代码：

public class Solution {
    public ListNode detectCycle(ListNode head) {
        //至少要存在两个节点
        if (head == null || head.next == null) {
            return null;
        }
        //定义快慢指针
        ListNode fast = head;
        ListNode slow = head;
        // 寻找快慢指针相遇点
        while (fast.next != null&&fast.next.next != null) {
            //移动指针快指针移动两格，慢指针移动一格
            fast = fast.next.next;
            slow = slow.next;
            //相遇
            if (fast == slow) {
                break;
            }
        }
        //无环情况
        if(fast==null||fast.next==null||fast.next.next==null){
            return null;
        }
        //让slow指针重新指向头指针
        slow=head;
        //再次循环，但每个指针只移动一格，寻找环入口
        while(slow!=fast){
            slow=slow.next;
            fast=fast.next;
        }
        return slow;

    }
}

空.白251
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值