代码随想录第四天| LeetCode24 两两交换链表中的节点 、 LeetCode19 删除链表的倒数第N个节点 、 面试题 02.07. 链表相交 、LeetCode142 环形链表II

最新推荐文章于 2024-10-05 15:32:05 发布
最新推荐文章于 2024-10-05 15:32:05 发布
阅读量66 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64566993/article/details/131999301
版权
本文介绍了四个关于链表的操作问题，包括两两交换链表中的节点、删除链表的倒数第N个节点、判断链表相交的起始节点以及寻找环形链表的入口节点。这些问题都涉及到对链表结构的理解和巧妙的迭代或指针操作。代码随想录提供了相应的解题思路和Java代码实现。
摘要由CSDN通过智能技术生成

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

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

        代码实现了题目解析：代码随想录两两交换链表中的节点

题目描述：

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

示例 ：

具体代码实现：


//两两交换链表中的节点

 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 swapPairs(ListNode head) {
    	ListNode dumyhead = new ListNode();
    	dumyhead.next = head;
    	ListNode cur = dumyhead;
    	while (cur.next != null && cur.next.next != null){
    		ListNode temp = cur.next ;
    		ListNode temp1 = cur.next.next.next ;
    		cur.next = cur.next.next ;
    		cur.next.next  = temp;
    		temp.next = temp1;
    		cur = cur.next.next;
    		
    	}
    	return dumyhead.next ;
    }
}


public class Solution_text {
    public static void main(String[] args){
    	ListNode head = new ListNode (Integer.parseInt(args[0]));
    	ListNode cur = new ListNode();
    	cur = head;                                                //保留头指针，创建副本来遍历
    	for(int i=1 ; i<args.length ; i++){                      //从主函数中传入参数创建列表
    		cur.next = new ListNode (Integer.parseInt(args[i]));
    		cur = cur.next;
    	}
    	// 打印原始链表
        System.out.println("原始链表：");
        printLinkedList(head);


    	Solution solution = new Solution();
    	// 调用 swapPairs 方法交换节点
    	ListNode modifiedListhead = solution.swapPairs(head);

    	// 打印修改后的链表
    	System.out.println("修改后的链表：");
    	printLinkedList(modifiedListhead);

	}

	//打印链表
	private static void printLinkedList(ListNode head1) {
		ListNode current = head1;
		while (current != null) {
			System.out.print(current.val + " ");
			current = current.next;
		}
		System.out.println();
	}
}

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

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

        代码实现了题目解析：代码随想录删除链表的倒数第N个节点

题目描述：

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

示例 ：

 

具体代码实现：


//删除列表倒数第n个元素

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 removeNthFromEnd(ListNode head, int n) {
    	ListNode dumyhead = new ListNode();
    	dumyhead.next = head;
    	ListNode fast = dumyhead;
    	ListNode slow = dumyhead;
    	n = n+1;                           //目的是让快指针多走一步，等快指针到达末尾空指针时，
    	                                   //慢指针刚好到达待删除指针的前一位，便于进行删除操作
    	while( n-- !=0 && fast != null)
    		fast = fast.next;
    	while(fast != null){
    		fast = fast.next;
    		slow = slow.next;
    	}
    	slow.next = slow.next.next ;
    	return dumyhead.next ;
    }
}

public class Solution_text {
    public static void main(String[] args){
    	ListNode head = new ListNode (Integer.parseInt(args[0]));
    	ListNode cur = new ListNode();
    	cur = head;                                                //保留头指针，创建副本来遍历
    	for(int i=1 ; i<args.length-1 ; i++){                      //从主函数中传入参数创建列表
    		cur.next = new ListNode (Integer.parseInt(args[i]));
    		cur = cur.next;
    	}
    	// 打印原始链表
        System.out.println("原始链表：");
        printLinkedList(head);


    	int val = Integer.parseInt(args[args.length-1]);  //确定待删除元素
        System.out.println("删除链表的倒数第" + val + "个元素");
    	
    	Solution solution = new Solution();
    	// 调用 removeElements 方法删除节点
    	ListNode modifiedListhead = solution.removeNthFromEnd(head,val);

    	// 打印修改后的链表
    	System.out.println("修改后的链表：");
    	printLinkedList(modifiedListhead);

	}

	//打印链表
	private static void printLinkedList(ListNode head1) {
		ListNode current = head1;
		while (current != null) {
			System.out.print(current.val + " ");
			current = current.next;
		}
		System.out.println();
	}
}

 面试题 02.07. 链表相交  

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

        代码实现了题目解析：代码随想录面试题 02.07. 链表相交

题目描述：

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

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

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

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

具体代码实现：

//找出并返回两个单链表相交的起始节点
import java.util.Scanner;

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 getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != null) { // 求链表A的长度
            lenA++;
            curA = curA.next;
        }
        while (curB != null) { // 求链表B的长度
            lenB++;
            curB = curB.next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            //1. swap (lenA, lenB);
            int tmpLen = lenA;
            lenA = lenB;
            lenB = tmpLen;
            //2. swap (curA, curB);
            ListNode tmpNode = curA;
            curA = curB;
            curB = tmpNode;
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap-- > 0) {
            curA = curA.next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != null) {
            if (curA == curB) {
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }

}
public class Solution_text {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个链表（以空格分隔节点值）：");
        ListNode head1 = readLinkedList(scanner.nextLine().trim());

        System.out.println("请输入第二个链表（以空格分隔节点值）：");
        ListNode head2 = readLinkedList(scanner.nextLine().trim());

        // 打印原始链表
        System.out.println("两个链表：");
        printLinkedList(head1);
        printLinkedList(head2);
        
        int len1 = 0, len2 = 0;
        ListNode cur1 = head1; 
        ListNode cur2 = head2; 
        while (cur1 != null) { // 求链表A的长度
            len1++;
            cur1 = cur1.next;
        }
        while (cur2 != null) { // 求链表B的长度
            len2++;
            cur2 = cur2.next;
        }

        if(len1 >= len2)
        	head1 = head2 ;                           
        else
            head2 = head1 ;   										//必须将两个链表相连才会有交点
        
        Solution solution = new Solution();
        // 调用 getIntersectionNode 方法获取重合的首节点
        ListNode intersectionNode = solution.getIntersectionNode(head1, head2);
        
        if (intersectionNode != null) {
            System.out.println("重合的首节点：" + intersectionNode.val);            //节点相交是同一个节点  不是同一个val值
        } else {
            System.out.println("链表没有相交的节点。");
        }
    }

    // 读取链表
    private static ListNode readLinkedList(String line) {
        String[] values = line.split(" ");
        ListNode dummy = new ListNode();
        ListNode curr = dummy;
        for (String value : values) {
            curr.next = new ListNode(Integer.parseInt(value));
            curr = curr.next;
        }
        return dummy.next;
    }

    // 打印链表
    private static void printLinkedList(ListNode head) {
        ListNode current = head;
        while (current != null) {
            System.out.print(current.val + " ");
            current = current.next;
        }
        System.out.println();
    }
}

 142.环形链表II  

        题目链接：142. 环形链表 II - 力扣（LeetCode）

        代码实现了题目解析：代码随想录环形链表II

题目描述：

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

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

不允许修改 链表。

示例 ：

 

具体代码实现：


//环形链表||

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 detectCycle(ListNode head) {
    	ListNode fast = head;
    	ListNode slow = head;
    	while(fast != null && fast.next != null){
    		fast = fast.next.next;                   //快指针一次走两步，只比慢指针多走一步，防止在追赶慢指针时，跳过了慢指针而没相遇
    		slow = slow.next ;                       //慢指针一次走一步
    		if(slow == fast){                        //当两指针相遇时
    			ListNode index1 = fast;
    			ListNode index2 = head;
                // 两个指针，从头结点和相遇结点，各走一步，直到相遇，相遇点即为环入口
    			//为什么相遇点即为环入口？ ，假设从头结点到环入口为x，环入口到相遇位置为y，剩余位置（即相遇位置到入口为Z）
    			//假设在快指针走过一圈循环(圈数不影响结论)就撵上慢指针时，2（x+y）= x+y+z+y  ===>  x=z
    			while(index1 != index2){
    				index1 = index1.next ;
    				index2 = index2.next ;
    			}
    			return index1;                      //
    		}
    	}
		return null;
    }
}
public class Solution_text {
    public static void main(String[] args){
    	ListNode head = new ListNode (Integer.parseInt(args[0]));
    	ListNode cur = new ListNode();
    	cur = head;                                                //保留头指针，创建副本来遍历
    	for(int i=1 ; i<args.length-1 ; i++){                      //从主函数中传入参数创建列表
    		cur.next = new ListNode (Integer.parseInt(args[i]));
    		cur = cur.next;
    		if(i == args.length-2){
    			cur.next = new ListNode (Integer.parseInt(args[i+1]));
    			cur = cur.next;
    			cur.next = head.next;                                 //假设把结尾的next（即null）指向第二个指针，形成环
    		}                                                         //所以结果肯定为第二个节点的值
    	}
    	

    	Solution solution = new Solution();
    	ListNode modifiedListhead = solution.detectCycle(head);

    	// 打印修改后的链表
    	System.out.println("环的入口：" + modifiedListhead.val);

	}

}

要动手啊
关注
【Leetcode刷题笔记04】24. 两两交换节点 19. 删除结点 07. 链表相交 142. 环形链表 II.md
01-13
删除链表的倒数第N个节点、面试题02.07.链表相交和142.环形链表II。记录了清晰的文字题解+图示以及Java参考代码。 适合人群:链表算法感兴趣的程序员或学生,想要打好数据结构与算法基础的人。 能学到什么:掌握链表...
just1296#leetcode#面试题02.07.链表相交1
07-25
换句话说，如果一个链表的第k个节点与另一个链表的第j个节点是同一节点（引用完全相同），则这两个链表相交。示例 1：输出：Reference of the nod
代码随想录第4天|Leetcode24 两两交换链表中节点、Leetcode19 删除链表的倒数第N个节点、面试题02.07 链表相交、Leetcode142 环形链表||
m0_73866076的博客
07-23 288
完成情况：AC 通过。
代码随想录刷题day4|LeetCode24 两两交换链表中的节点、LeetCode19 删除链表的倒数第N个节点、LeetCode02.07 链表相交、LeetCode142 环形链表II
m0_73687551的博客
09-03 815
这样的速度比例还有一个好处，快指针相对于慢指针以每次移动一个结点的速度追赶慢指针，不会出现赶上慢指针但是跳过慢指针而没法相遇的情况。，故需要确定相遇的结点（可在判断是否存在环的过程中求得），此时再使用两个新指针分别从相遇点和头结点同时出发（在这里k=1可以理解为两个指针的速度比例为1），直到两新指针相遇，相遇的新结点就是环入口。当链表不存在环时，快指针一定会先走完整个链表，两指针不会相遇。列个简单的相遇问题等式，由于快指针所走路程是慢指针的两倍，且在两指针相遇时快指针有可能已经转了若干圈，可得原型式。
代码随想录day4｜Leetcode 24、两两交换链表中的节点｜Leetcode 19、删除链表的倒数第N个节点｜面试题 02.07 链表相交｜Leetcode 142、环形链表II｜Golang
weixin_42161901的博客
09-24 370
代码随想录day4-链表
代码随想录算法训练营第四天 | Leetcode 24 两两交换链表中的节点 Leetcode 19 删除链表的倒数第N个节点 02.07 链表相交 Leetcode 142 环形链表II
m0_72920008的博客
07-21 788
这道题用了双指针 （快慢指针）通过快慢指针的位置来找到需要删除的位置比如倒数第2个位置怎么找到 让快指针比慢指针多走2格 所以慢指针的后一个位置就是需要删除的位置。先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。用双指针法 定一个快指针和一个慢指针 快指针走2格 慢的走一格 ，如果有环他们就会相遇，，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。
代码随想录算法训练营第四天 | LeetCode 24 两两交换链表中的节点 LeetCode19 删除链表的倒数第N个节点 面试题 02.07. 链表相交 LeetCode142 环形链表II
qq_51313170的博客
01-13 450
代码随想录每日打卡
代码随想录第四天|LeetCode 24两两交换链表中的结点，19删除链表的倒数第N个节点，面试题 02.07链表相交，142环形链表II
weixin_62190204的博客
01-22 165
链表练习
代码随想录 Day4 | Leetcode24 两两交换链表中的节点、Leetcode19 删除链表的倒数第N个节点、面试题 02.07 链表相交、Leetcode142 环形链表II
qq_41502639的博客
01-05 1076
同是碳基生物，怎么差别这么大。。。。
代码随想录第四天|LeetCode24. 两两交换链表中的节点，LeetCode19.删除链表的倒数第N个节点,LeetCode面试题 02.07. 链表相交,LeetCode142.环形链表II
yec10的博客
05-28 1968
LeetCode24. 两两交换链表中的节点思路：先定义一个虚拟头结点方便操作。再就是交换相邻两个元素了，初始时，cur指向虚拟头结点，然后进行如下三步（比较懒直接用Carl哥图了HH）：LeetCode19.删除链表的倒数第N个节点思路：本人的思路是设置一个虚拟头结点在头结点前面遍历一遍得出链表长度再减去输入的数字，再遍历一遍后直接将倒数第n+1个结点接在第n-1个结点后面，是可行的。
代码随想录Day4| LeetCode 24 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II
luyimin87的博客
03-23 930
一定是快指针先进入这个环，然后慢指针才进入这个环，快在追慢的过程，快指针是以什么速度接近慢指针呢。相对于慢指针快指针的速度是每次移一个节点的移动速度。所以他两一定会相遇。此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。为了方便举例，假设节点元素数值相等，则节点指针相等。从起始位置到入口处x，相遇到入口y，y到出口是z。
MangoDowner#clear-leetcode#面试题02.07.链表相交1
07-25
面试题 02.07. 链表相交原题链接：面试题 02.07. 链表相交解法一：首尾相接法解题思路将这两个链表首尾相连，然后检测这个链表是否存在环，如果存在，则两
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 375
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】双向链表（Doubly Linked List）
最新发布
2301_77727857的博客
10-05 310
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
数据结构（栈和队列的实现）
2301_80475151的博客
09-30 1155
这里介绍了栈的实现和队列的实现，还有栈和队列的OJ题例如用栈实现队列和用队列实现栈等‘；
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 351
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
动态顺序表的增删改查（数据结构）
m0_62048999的博客
09-28 1217
顺序表是数据结构的基础知识，通过学习次内容，可以让我们了解顺序表中数据中是如何进行存储，删除，插入数据的。
数据结构之图（6）
2301_76246515的博客
10-05 523
图G有顶点集V和边集E组成，记为G=(V,E),其中V（G）表示图G中顶点的有限非空集；E(G)表示图G中顶点之间的关系（边）集合。若V={v1,v2,…，vn}，则用|V|表示图G中顶点的个数。也称为图G的阶E={（u,v)|u ∈​​​V},用|E|表示图G中边的条数图不可以是空，V一定是非空集E是无向边（简称边）的有限集合E是有向边（弧）的有限集合弧是顶点的有序对，记为<v,w>,v为弧尾，w为弧头不存在重复边不存在顶点到自身的边。
C语言实现leetcode 24题：两两交换链表中的节点
具体来说，给定一个单向链表，将链表中相邻的节点两两交换，例如输入1->2->3->4，应返回2->1->4->3。在C语言中实现这个算法需要对链表操作有一定了解，包括节点的创建、遍历和指针的调整等。这个问题是典型的链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值