Q2.3 删除中间节点
实现一种算法,删除单向链表中间的某个节点(即不是第一个或最后一个节点),假定你只能访问该节点。
示例:
输入:单向链表a->b->c->d->e->f中的节点c
结果:不返回任何数据,但该链表变为a->b->d->e->f
解题思路
解法一:与后结点交换数值,然后删除后结点
思路:由于只能访问当前结点,删除元素一般需要前置结点,所以可以把当前结点的值与后结点交换再删除后结点
分析:时间复杂度是常数级,效率很快,不需要额外内存空间
//解法一:与后结点交换数值,再删除后结点
public static void test1(ListNode node) {
ListNode next_node = node.next;
//交换两个结点的值
int temp = next_node.val;
next_node.val = node.val;
node.val = temp;
//下面删除next_node
node.next=next_node.next;
//测试
/*while(node!=null){
System.out.println(node.val);
node=node.next;
}*/
}
方法二:
class Solution {
public void deleteNode(ListNode node) {
//删除当前节点node ,可以删去其下一个节点,
//并将下一个节点的值赋值给当前节点
node.val = node.next.val;
node.next = node.next.next;
}
}
Q2.4 分割链表
编写程序以 x 为基准分割链表,使得所有小于 x 的节点排在大于或等于 x 的节点之前。如果链表中包含 x,x 只需出现在小于 x 的元素之后(如下所示)。分割元素 x 只需处于“右半部分”即可,其不需要被置于左右两部分之间。
示例:
输入: head = 3->5->8->5->10->2->1, x = 5
输出: 3->1->2->10->5->5->8
class Solution {
/*
这个题目的意思其实是:将所有小于 x 的节点放在 x 节点之前
例如:
[1,4,3,2,5,2] 3 -> [1, 2, 2, 3, 4, 5]
[3, 5, 8, 5, 10, 2, 1] 5 -> [1, 2, 3, 5, 5, 8, 10]
方法: 双指针
cur 为遍历的当前节点。pre 为遍从前向后第一个未交换的节点
cur 向后遍历过程总若遇到小于 x 的元素 则与pre 进行交换
*/
public ListNode partition(ListNode head, int x) {
ListNode cur = head;
ListNode pre = head;
while (cur != null) {
if (cur.val < x) {
swap(cur, pre);
pre = pre.next;
}
cur = cur.next;
}
return head;
}
public void swap(ListNode p1, ListNode p2) {
int temp = p1.val;
p1.val = p2.val;
p2.val = temp;
}
}
Q2.5 链表求和
给定两个用链表表示的整数,每个节点包含一个数位。这些数位是反向存放的,也就是个位排在链表首部。编写函数对这两个整数求和,并用链表形式返回结果。这些数位是反向存放的,也就是个位排在链表首部。编写函数对这两个整数求和,并用链表形式返回结果。
输入:(7 -> 1 -> 6) + (5 -> 9 -> 2),即617 + 295
输出:2 -> 1 -> 9,即912
进阶:假设这些数位是正向存放的,请再做一遍。
输入:(6 -> 1 -> 7) + (2 -> 9 -> 5),即617 + 295
输出:9 -> 1 -> 2,即912
思路:
用递归解法,分别从两个链表的第一个节点开始,取一个值相加,相加的结果对10取模,取模得到值作为结果的一位节点。重复上述操作再从两个链表的下一位取值相加( 注 意 得 加 上 前 一 次 操 作 的 进 位 ) \color{red}{(注意得加上前一次操作的进位)}(注意得加上前一次操作的进位),结果存入结点,通过递归将这些节点连接起来。
/**
-
Definition for singly-linked list.
-
public class ListNode {
-
int val;
-
ListNode next;
-
ListNode(int x) { val = x; }
-
}
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
//add为求和函数
ListNode res = add(l1, l2, 0);
return res;
}
//head1和head2分别为两个链表的第一个元素,value为上一次操作的进位
static ListNode add(ListNode head1,ListNode head2, int value) {
if (head1 == null && head2 == null) {
if (value == 1) {
//最后还有进位需要生成最后一个值为1的节点
return new ListNode(1);
} else {
//已完成最后一位的相加操作,开始逐层返回
return null;
}
}
if (head1 != null) {
//链表1要相加的那位不为空就把值加上
value += head1.val;
}
if (head2 != null) {
//链表2要相加的那位不为空就把值加上
value += head2.val;
}
//如果两个值相加后>=10就会产生进位,对10取模可得到减去进位的值
ListNode res = new ListNode(value % 10);
//如果两位相加的值小于10则没有进位,即进位为0
//如果两位相加的值>=10,则要向高位进1
//此处value值的意义变成了向高位的进位
value = value < 10 ? 0 : 1;
//此处的三目运算符功能是防止产生空指向异常,只有head1或者head2
//不为空的情况才下才有next节点
//传入的value值为向高位的进位
res.next = add(head1null?null:head1.next, head2null?null:head2.next, value);
return res;
}
}
Q2.6 回文链表
编写一个函数,检查输入的链表是否是回文的。
示例 1:
输入: 1->2
输出: false
示例 2:
输入: 1->2->2->1
输出: true
class Solution {
public boolean isPalindrome(ListNode head) {
if(head == null || head.next == null){
return true;
}
//找到链表中间点
ListNode low = head;
ListNode fast = head;
while(fast != null && fast.next != null){
low = low.next;
fast = fast.next.next;
}
if(fast != null){//说明有奇数个结点,low需要再走一步。
low = low.next;
}
//翻转后半段链表
ListNode cur = low.next;
low.next = null;
while(cur != null){
ListNode temp = cur.next;
cur.next = low;
low = cur;
cur = temp;
}
//比较前后段是否一致
while(low != null){
if(low.val != head.val){
return false;
}
low = low.next;
head = head.next;
}
return true;
}
}
Q2.7 链表相交
给定两个(单向)链表,判定它们是否相交并返回交点。请注意相交的定义基于节点的引用,而不是基于节点的值。换句话说,如果一个链表的第k个节点与另一个链表的第j个节点是同一节点(引用完全相同),则这两个链表相交。
示例 1:
输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出:Reference of the node with value = 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
输出:Reference of the node with value = 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。
注意:
如果两个链表没有交点,返回 null 。
在返回结果后,两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度,且仅用 O(1) 内存。
总结:
1.这里是单项链表,不可能出现剪刀形状的相交。
2.这里的是的相交是下面的情况
3.让两个节点分别从一个链表的首部开始,走完一个链表重新走另外一个链表,如果相遇必然相交,因为走的路径都是AD+DC+BD
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if(headAnull||headBnull)
{
return null;
}
ListNode p1=headA;
ListNode p2=headB;
while(p1!=p2)
{
p1=p1==null? headB:p1.next;
p2=p2==null? headA:p2.next;
}
return p1;
}
}
Q2.8 环路检测
给定一个链表,如果它是有环链表,实现一个算法返回环路的开头节点。
如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环。注意:pos 不作为参数进行传递,仅仅是为了标识链表的实际情况。
示例 1:
输入:head = [3,2,0,-4], pos = 1
输出:tail connects to node index 1
解释:链表中有一个环,其尾部连接到第二个节点。
示例 2:
输入:head = [1,2], pos = 0
输出:tail connects to node index 0
解释:链表中有一个环,其尾部连接到第一个节点。
示例 3:
输入:head = [1], pos = -1
输出:no cycle
解释:链表中没有环。
/**
-
判断链表是否有环:
-
设置快指针和慢指针,慢指针每次走一步,快指针每次走两步
-
当快指针与慢指针相等时,就说明该链表有环
*/
public boolean isRinged(Node head){
if(head == null){
return false;
}
Node slow = head;
Node fast = head;
while(fast.next != null && fast.next.next != null){
slow = slow.next;
fast = fast.next.next;
if(fast == slow){
return true;
}
}
return false;
}
Q2.9 给定一个有环链表,实现一个算法返回环路的开头结点
(1)创建两个指针:FastPointer和SlowPointer。
(2)SlowPointer每走一步,FastPointer就走两步。
(3)两者碰在一起时,将SlowPointer指向LinkedListHead,FastPointer保持不变。
(4)以相同速度移动SlowPointer和FastPointer,一次一步,然后返回新的碰撞处。
LinkedListNode findBegining(LinkedListNode head) {
LinkedListNode slow = head;
LinkedListNode fast = head;
/找出碰撞处,将处于链表中LOOP_SIZE-k步的位置/
while(fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
if(slow == fast) { // 碰撞
break;
}
}
/错误检查,没有碰撞处,也即没有回路/
if(fast == null || fast.next == null) {
return null;
}
/*将slow指向首部,fast指向碰撞处,两者距离环路
*起始处k步,若两者以相同速度移动,则必定会在环
路起始处碰在一起/
slow = head;
while(slow != fast) {
slow = slow.next;
fast = fast.next;
}
总结
最后小编想说:不论以后选择什么方向发展,目前重要的是把Android方面的技术学好,毕竟其实对于程序员来说,要学习的知识内容、技术有太多太多,要想不被环境淘汰就只有不断提升自己,从来都是我们去适应环境,而不是环境来适应我们!
这里附上我整理的几十套腾讯、字节跳动,京东,小米,头条、阿里、美团等公司19年的Android面试题。把技术点整理成了视频和PDF(实际上比预期多花了不少精力),包含知识脉络 + 诸多细节。
由于篇幅有限,这里以图片的形式给大家展示一小部分。
网上学习 Android的资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。
技术进阶之路很漫长,一起共勉吧~
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》,点击传送门,即可获取!
if(fast == null || fast.next == null) {
return null;
}
/*将slow指向首部,fast指向碰撞处,两者距离环路
*起始处k步,若两者以相同速度移动,则必定会在环
路起始处碰在一起/
slow = head;
while(slow != fast) {
slow = slow.next;
fast = fast.next;
}
总结
最后小编想说:不论以后选择什么方向发展,目前重要的是把Android方面的技术学好,毕竟其实对于程序员来说,要学习的知识内容、技术有太多太多,要想不被环境淘汰就只有不断提升自己,从来都是我们去适应环境,而不是环境来适应我们!
这里附上我整理的几十套腾讯、字节跳动,京东,小米,头条、阿里、美团等公司19年的Android面试题。把技术点整理成了视频和PDF(实际上比预期多花了不少精力),包含知识脉络 + 诸多细节。
由于篇幅有限,这里以图片的形式给大家展示一小部分。
[外链图片转存中…(img-KC8PWmqM-1714934080995)]
网上学习 Android的资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。
技术进阶之路很漫长,一起共勉吧~
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》,点击传送门,即可获取!