剑指offer——有关链表的算法题详解

最新推荐文章于 2024-10-20 10:43:07 发布
最新推荐文章于 2024-10-20 10:43:07 发布
阅读量205 收藏 1
点赞数
分类专栏： 剑指offer 文章标签： 链表 算法 数据结构 java leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mkfka/article/details/107239850
版权

有关链表的算法题

1、链表的倒数第K个结点

题目描述：输入一个链表，输出该链表中倒数第k个结点。
方法一：倒数，可以利用栈去存储链表的所有结点，然后出栈K个结点，第K个就是倒数第K个结点。

	private static ListNode FindKthToTail(ListNode head, int k) {
		if (head==null || k==0 ) {
			return null;
		}
		Stack<ListNode> stack = new Stack<ListNode>();
		while (head!=null) {
			stack.push(head);
			head = head.next;
		}
		for (int i = 0; i < k - 1; i++) {
			stack.pop();
		}
		if (!stack.isEmpty()) {
			return stack.pop();
		}
		return null;
	}

方法二：采用两个指针，让其中一个指针先走K步，然后两个指针同时向前走，当快指针达到链表尾时，慢指针指向的结点就是倒数第K个结点。如图所示：
在这里插入图片描述
代码如下：

private static ListNode FindKthToTail(ListNode head, int k) {
		if (head == null || k == 0) {
			return null;
		}
		ListNode fast = head ; 
		ListNode slow = head ; 
		for (int i = 0; i < k - 1; i++) {  //倒数K个，应该移动k-1个结点
			fast = fast.next;
			if (fast == null) {
				return null;
			}
		}
		while (fast.next!=null) {
			fast = fast.next;
			slow = slow.next;
		}
		return slow;
	}

2、从尾到头打印链表（递归和非递归）

方法一：利用java集合容器自带的反转方法。
先遍历链表中的每一个结点，使用Collections集合中的反转方法reverse（）将链表中的数从尾到头打印。

public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> arrayList=new ArrayList<>();
        while (listNode!=null) {
            arrayList.add(listNode.val);
            listNode=listNode.next;
        }
        Collections.reverse(arrayList); 
        return arrayList;
    }

方法二: 根据从尾到头打印，说明后进先出，使用栈去保存链表中的结点，然后再pop出来。代码如下：


public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
		Stack<Integer> stack = new Stack<Integer>();
		while (listNode!=null) {
			stack.push(listNode.val);
			listNode=listNode.next;
		}
		while (!stack.isEmpty()) {
			arrayList.add(stack.pop());
		}
		return arrayList;
    }

方法三:采用递归的方法去保存链表中的数。

 public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
		printLinkList(arrayList,listNode);
		return arrayList;
    }
    private  void printLinkList(ArrayList<Integer> arrayList, ListNode listNode) {
		if (listNode!=null) {
			if (listNode.next !=null) {
				printLinkList(arrayList,listNode.next);
			}
			arrayList.add(listNode.val);
		}
	}

3、链表有关环的算法题

3.1 如何判断一个链表有环

判断一个链表是否有环，我们通常采用两个速度不同的指针，同时移动，如果链表中有环，两个指针最终会在某一个结点相遇。代码如下：

private static boolean isLoop(ListNode head) {
		ListNode fast = head ; 
		ListNode slow = head ; 
		if(head.next==null||head.next.next==null)
            return false;
		fast = head.next.next;
		slow = slow.next;
		while (fast.next!=null&& fast.next.next!=null) {
			if (fast == slow) {
				return true ;
			}
			fast = fast.next.next;
			slow = slow.next;
		}
		return false;
	}

3.2 计算链表中环的大小

解题思路：前面使用快慢指针，当快慢指针有相遇则可以判断链表中有环，这是第一次相遇，当保持一个指针不动，另一个指针移动，那么我们可以从第一次相遇开始计数，当指针第二次相遇时，即可得到环的大小。代码如下：

/**  
	 * @Description: TODO(获取环的大小)
	 * @param head
	 * @return
	 * @author Mr.Wang
	 * @date 2020-07-10 01:10:38 
	 */  
	private static int getLoopSize(ListNode head) {
		
		ListNode current = getLoopNode(head);
		if (current == null) {
			return 0;
		}
		int len = 1;
		ListNode  node = current.next; 
		while (current != node) {
			len++;
			node = node.next;
		}
		return len;
	}
	/**  
	 * @Description: TODO(获取第一次相遇时的结点)
	 * @param head
	 * @return
	 * @author Mr.Wang
	 * @date 2020-07-10 01:10:23 
	 */  
	private static ListNode getLoopNode(ListNode head) {
		ListNode fast = head ; 
		ListNode slow = head ; 
		if(head.next==null||head.next.next==null)
            return null;
		fast = head.next.next;
		slow = slow.next;
		while (fast.next!=null&& fast.next.next!=null) {
			if (fast == slow) {
				return slow ;
			}
			fast = fast.next.next;
			slow = slow.next;
		}
		return null;		
	}

3.3 链表中环的入口结点

题目分析：分两步走：1、判断链表是否有环 2、求环的入口。
在这里插入图片描述
方法一：求出环的大小size，然后让快指针先走size个结点，然后慢指针与快指针同时移动，当快慢指针相遇时，相遇的结点就是入口；代码如下：

private static ListNode EntryNodeOfLoop(ListNode pHead) {
		ListNode fast = pHead;
		ListNode slow = pHead;
		if (isLoop(pHead)) {
			int len = getLoopSize(pHead);
			for (int i = 0; i < len; i++) {
				fast= fast.next;
			}
			while (fast != slow) {
				fast = fast.next;
				slow = slow.next;
			}
			return fast;
		}
		return null;
	}
	/**  
	 * @Description: TODO(获取环的大小)
	 * @param head
	 * @return
	 * @author Mr.Wang
	 * @date 2020-07-10 01:10:38 
	 */  
	private static int getLoopSize(ListNode head) {
		
		ListNode current = getLoopNode(head);
		if (current == null) {
			return 0;
		}
		int len = 1;
		ListNode  node = current.next; 
		while (current != node) {
			len++;
			node = node.next;
		}
		return len;
	}
	/**  
	 * @Description: TODO(获取第一次相遇时的结点)
	 * @param head
	 * @return
	 * @author Mr.Wang
	 * @date 2020-07-10 01:10:23 
	 */  
	private static ListNode getLoopNode(ListNode head) {
		ListNode fast = head ; 
		ListNode slow = head ; 
		if(head.next==null||head.next.next==null)
            return null;
		fast = head.next.next;
		slow = slow.next;
		while (fast.next!=null&& fast.next.next!=null) {
			if (fast == slow) {
				return slow ;
			}
			fast = fast.next.next;
			slow = slow.next;
		}
		return null;		
	}
	/**  
	 * @Description: TODO(判断链表是否有环)
	 * @param head
	 * @return
	 * @author Mr.Wang
	 * @date 2020-07-10 08:12:36 
	 */  
	private static boolean isLoop(ListNode head) {
		ListNode fast = head ; 
		ListNode slow = head ; 
		if(head.next==null||head.next.next==null)
            return false;
		fast = head.next.next;
		slow = slow.next;
		while (fast.next!=null&& fast.next.next!=null) {
			if (fast == slow) {
				return true ;
			}
			fast = fast.next.next;
			slow = slow.next;
		}
		return false;
	}

方法二：先求出快慢指针相遇的结点，然后让快指针回到head处，然后快慢指针以同样的移动速度移动，一定会在环的入口处相遇，相遇的结点就是环的入口。代码如下：

private static ListNode EntryNodeOfLoop(ListNode pHead) {
		if(pHead.next==null||pHead.next.next==null)
            return null;
		ListNode fast = pHead.next.next;
		ListNode slow = pHead.next;
		if (slow ==null || fast == null) {
			return pHead;
		}
		
		while (fast!=null) {
			if (fast == slow) {
				fast = pHead;  //让快指针指向头结点
				while (fast != slow) {
					fast = fast.next;
					slow = slow.next;
				}
				return fast;
			}
			if (fast.next==null||fast.next.next==null || slow.next==null) {
				return null;
			}
			fast = fast.next.next;
			slow = slow.next;
		}
		return null;
	}

此方法代码量很显然比方法一代码量要少，但是有同学可能不是很明白，为什么当快慢结点在环内相遇时，将快结点指向头结点，同时以相同的速度移动，他们会在环的入口处相遇呢？？？
在这里插入图片描述
A为头结点，B为链表环的入口，M为快慢指针相遇点，则慢指针走的路程x(slow) = l+b，快指针走的路程：x(fast) = l+b+n(a+b)，其中n为圈数,且n>=1(如果n=0的快慢指针走的路程一样，不符合逻辑)。有因为快指针一次走两个结点，慢指针一次只走一个结点。所以2x(slow) = x(fast) => l = n(a+b)-b = (n-1)(a+b) + a其中n>=1. a表示M到B点的距离，（a+b）表示环的长度，也就是说，从M点出发，到达B点后，以B为起点绕n-1圈，和以A为起点，走距离为l，两者一定会在B点相遇。

方法三：环的特征可得知，所有结点中只有入口结点会有两个指针同时指向它。使用断链法，在当前结点访问完毕后，断掉指向当前结点的指针。因此，最后一个被访问的结点一定是入口结点。
该方法转载至博客：https://www.cnblogs.com/darlinFly/p/9335380.html
在这里插入图片描述在这里插入图片描述

4、反转链表

算法思路：想要链表反转，只需要将链表里面的指针反转就行。
链表如下：
（1）
先上代码：

 public ListNode ReverseList(ListNode head) {
		if (head==null) {
			return null;
		}
		ListNode pre=null;
		ListNode next=null;
		while (head!=null) {
			next=head.next;   	//(1)
			head.next=pre;	  	//(2)
			pre=head; 			//(3)
			head=next;			//(4)
		}
		return pre;
    }

算法解释如图
代码（1）表示如图：
（2）
使用next指针指向head.next的结点。
代码（2）表示如图：
（3）
红色表示的head.next结点，也就是next指针所指向的结点。将head与next所指向的结点链接断开，将head.next指向pre指向的结点。如图所示；
代码（3）如图：
在这里插入图片描述
将pre指针指向head所指向的指针，使pre指向的结点为反向链表的头结点;
代码（4）如图所示：
在这里插入图片描述

5、两个链表的第一个公共结点

**算法分析：**两个链表的公共结点，只要出现了公共结点，则第一个公共结点后面都是公共的，形成重合链，示意图如下图：
在这里插入图片描述
由上图可知，只需计算两个链表的长度，求出长度差a，让长度长的链表指针先走a步，然后让两个链表指针同时移动，当两个指针指向的结点相同时，该结点就为两个链表的第一个公共结点。代码如下：

private static ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
		ListNode root1 = pHead1;
		ListNode root2 = pHead2;
		int length1=0,length2=0;
		while (root1!=null) {
			length1++;
			root1 = root1.next;
		}
		while (root2!=null) {
			length2++;
			root2 = root2.next;
		}
		int len = 0;
		if (length1<=length2) {
			len = length2-length1;
			for (int i = 0; i < len; i++) {
				pHead2 = pHead2.next;
			}
		}else
		{
			len = length1 - length2;
			for (int i = 0; i < len; i++) {
				pHead1 = pHead1.next;
			}
		}
		while (pHead1 != pHead2) {
			pHead1 = pHead1.next;
			pHead2 = pHead2.next;
		}
		return pHead1;
	}

6、合并两个排序的链表

合并两个排序的链表有两种思路：
（1）非递归方法
代码如下：

   public ListNode Merge_2(ListNode list1,ListNode list2) {
    	if(list2 == null) {
    		return list1;
    	}
    	else if(list1 == null) {
    		return list2;
    	}
    	ListNode mergeHead = new ListNode(0);
    	ListNode current = mergeHead;
    	while(list1 != null && list2 != null) {
    		if(list1.val < list2.val) {
    			current.next = list1;
    			list1 = list1.next;
    		}
    		else {
    			current.next = list2;
    			list2 = list2.next;
    		}
    		current = current.next;
    	}
    	if(list1 == null) {
    		current.next = 	list2;
    	}
    	if(list2 == null) {
    		current.next = list1;
    	}
    	return mergeHead.next;
    }

（2）递归方法
合并两个排序链表过程中，每一次合并一个结点的操作都是重复的，并且当某一链表的结点为null时，递归结束。大概步骤如下：
1）分别取两个链表头结点，head1、head2
2）比较head1与head2大小
3）如果head1小，将head1保存在合并之后的链表中,将head1.next 作为新的头结点；反之，将head2保存在合并之后的链表中，将head2.next 作为新的头结点；
4）重复1）、2）、3）。
代码如下：

public ListNode Merge(ListNode list1,ListNode list2) {
        	if(list1 == null){
	            return list2;
	        }
	        if(list2 == null){
	            return list1;
	        }
	        if(list1.val <= list2.val){
	            list1.next = Merge(list1.next, list2);
	            return list1;
	        }else{
	            list2.next = Merge(list1, list2.next);
	            return list2;
	        }   
    }

7、单链表在时间复杂度为O(1)删除链表结点

算法分析：初次看到题目，有两种思路，分别是（1）找到该结点的上一个结点，让上一个结点的next指向删除结点的下一个结点即可。如图：
在这里插入图片描述
要想找到删除结点的上一个结点必须遍历链表寻找，复杂度为o(n)，不满足题意
（2）用该结点的下一个结点，覆盖要被删除的结点。代码如下：

  public void deleteNode(ListNode node) {
        node.val=node.next.val;   //val值 覆盖
        node.next=node.next.next;  //将node指针指向node下下个结点
    }

在这里插入图片描述

总结

这几种算法的总结希望可以帮助到大家对链表这种数据结构的理解。

mkfka
关注
专栏目录
自定义链表实现简单的队列poll()、offer()、peek()方法
qq_43357821的博客
03-16 912
class Node { int val; Node next; public Node(int val) { this.val = val; this.next = null; } } class FakeQueue { Node head; Node tail; public void offer(int val) { Node node = new Node(val...
链表类算法题
qq_33690342的博客
02-19 649
1、反转链表leetcode 206： // ListNode Definition for singly-linked list. type ListNode struct { Val int Next *ListNode } func reverseList(head *ListNode) *ListNode { if head == nil || head.Next == nil { return head } var prev *Li
算法学习随笔 3_链表有关算法题
P_in_k的博客
03-20 616
本章记录一些有关数组的一些较为经典或者自己第一次做印象比较深刻的算法以及题型，包含自己作为初学者第一次碰到题目时想到的思路以及网上其他更优秀的思路，本章持续更新中......
剑指offer（链表的算法题）
u012864854的博客
05-18 960
本文包含链表的以下内容： 　　1、查找单链表中的倒数第k个结点（剑指offer，题15） 　　2、合并两个有序的单链表，合并之后的链表依然有序【出现频率高】（剑指offer，题17） 　　3、单链表的反转【出现频率最高】（剑指offer，题16） 　　4、从尾到头打印单链表（剑指offer，题5） 　　5、单链表中，取出环的起始点（剑指offer，题56） 　　6、判断两个单链表相交的...
ConcurrentLinkedQueue的offer方法
zjuwzp的博客
01-01 3454
1、构造函数 public ConcurrentLinkedQueue() { head = tail = new Node<E>(null); } 点击new Node(null)进入如下代码 Node(E item) { UNSAFE.putObject(this, itemOffset, item); } 这里的itemOffset是item这个属性相对于No...
牛客网剑指offer66题思路分析.rar
05-07
《牛客网剑指Offer66题Python解题思路分析》 在编程的世界里，面试是程序员职业生涯中不可或缺的一部分，而“剑指Offer”作为中国程序员面试的经典书籍，深受广大开发者喜爱。本压缩包文件“牛客网剑指offer66题...
O(1)时间删除链表节点：剑指Offer算法详解
在《剑指Offer》这本书中，包含了丰富的IT算法题和数据结构问题，主要针对Java程序员，旨在帮助求职者提升面试中的各项能力。以下是一些关键知识点的详细讲解： 1. **O(1)时间删除链表节点**：此部分讨论的是在链表...
剑指Offer(题目和答案)
01-31
"剑指Offer"是一本针对面试准备的书籍，包含了许多常见的编程面试题。通过解决这些题目，可以提升编程能力，理解和熟练掌握各种算法和数据结构，为面试做好充分准备。 总结，以上内容涵盖了二维数组查找、字符串...
剑指Offer解题指南：算法详解与实践
"剑指Offer是一本针对编程面试的经典书籍，包含了各种算法和编程问题的解答。这份文档详细解析了书中的每一道题目，旨在帮助读者掌握编程面试的关键技巧和知识。" 这篇文档主要涵盖了以下几个方面的知识点： 1. **...
链表——剑指offer
小强的博客
05-23 230
从尾到头打印链表 思路：先把链表翻转，然后将翻转后的链表打印出来 这种方法:因为多分配链表节点指针，故可能会对内存的消耗要大一点 时间复杂度为O（n） vector&lt;int&gt; printListFromTailToHead(listnode *head) { vector&lt;int&gt;a; listnode *p=NULL; listnode *p1=NULL;...
剑指offer——链表
happy_Jianghui的博客
06-19 280
链表算法
剑指offer-链表
爆头战斧
03-10 120
剑指 Offer 06. 从尾到头打印链表 输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。 示例 1： 输入：head = [1,3,2] 输出：[2,3,1] 限制： 0 <= 链表长度 <= 10000 方法一：辅助栈法 解题思路： 链表特点： 只能从前至后访问每个节点。 题目要求： 倒序输出节点值。 这种 先入后出 的需求可以借助 栈 来实现。 思路： 入栈： 遍历链表，使用 append() 方法将各节点值 push 入栈。 出栈： 将各节点值 pop 出栈，存
算法训练——链表算法
庄小焱
01-29 1234
本系列博文将主要是学习和分享的算法基本相关问题和解答思路，帮助小伙伴更好理解相关的算法中有关于链表的内容。
链表经典算法题实现
思考、总结、专注
09-18 2711
本文包含链表的以下内容： 　　1、单链表的创建和遍历 　　2、求单链表中节点的个数 　　3、查找单链表中的倒数第k个结点（剑指offer，题15） 　　4、查找单链表中的中间结点 　　5、合并两个有序的单链表，合并之后的链表依然有序【出现频率高】（剑指offer，题17） 　　6、单链表的反转【出现频率最高】（剑指offer，题16） 　　7、从尾到头打印单链表（剑指offer，题5...
链表相关算法题总结
qq_31984717的博客
11-29 735
1.环形链表插值 有一个整数val，如何在节点值有序的环形链表中插入一个节点值为val的节点，并且保证这个环形单链表依然有序。 给定链表的信息，及元素的值A及对应的nxt指向的元素编号同时给定val，请构造出这个环形链表，并插入该值。 测试样例： [1,3,4,5,7],[1,2,3,4,0],2 返回：{1,2,3,4,5,7} ListNode* insert(vector...
二分查找算法（折半查找算法）
最新发布
Mooczx的博客
10-20 309
是一种在有序数组中查找特定元素的搜索算法。该算法通过将数组分成两半，逐步缩小查找范围来提高查找效率。具体来说，每次比较中间元素与目标值，根据比较结果决定是继续在左半部分还是右半部分进行查找，从而每次迭代都能排除一半的查找空间，时间复杂度对数级别O(logn)
Javascript算法——双指针法移除元素、数组去重、比较含退格字符、有序数组平方
警警的博客
10-17 467
暴力求解法（两层for循环）,length单词拼写错误❌二次嵌套for的length设置。return位置❌ ,核心基础。双指针法（一层for循环）
【算法】深入了解 CRC 校验码的计算过程
qq_20623849的博客
10-16 567
CRC（循环冗余校验，Cyclic Redundancy Check）是一种常见的错误检测方法，它通过生成冗余码来确保数据传输的可靠性。在这篇文章中，我们将探讨 CRC 码的基本原理，并详细介绍其计算过程。通过对数据进行 CRC 校验，我们可以在传输过程中检测到潜在的错误并采取适当的纠正措施。这个新的数据包在传输时，如果接收方再次计算 CRC 校验码并与附带的校验码进行比较，可以确定数据是否在传输过程中出现了错误。：将附加了零位的数据通过生成多项式进行二进制除法运算，得出的余数就是 CRC 校验码。
【LeetCode热题100】分治-归并
qq_48460693的博客
10-20 256
分治-排序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值