算法通关——链表高频面试题

已于 2023-11-01 16:49:57 修改
阅读量102 收藏
点赞数
文章标签： 算法 链表 java 1024程序员节
于 2023-11-01 16:43:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53178989/article/details/133979639
版权

1.两链表第一个公共子节点

1.1哈希集合

public ListNode findFirstCommonNodeBySet(ListNode headA,ListNode headB){
    Set<ListNode> set = new HashSet<>();
    while(headA != null){
        set.add(headA);
        headA = headA.next;
    }
    while(headB != null){
        if(set.contain(headB)){
            return headB;
        }
        headB = headB.next;
    }
    return null;
}

1.2栈

将两个链表的两个节点分别入两个栈，然后分别出栈，相等就继续出栈，最晚出栈的那一组即两个链表的第一个公共子节点。（花费2n(O)的空间复杂度）

Java的java.util.Stack类是java.util.Vector的子类，用于实现堆栈。下列常见操作

  1. push(E item): 把项压入栈顶。
  2. pop(): 移除栈顶项并作为此函数的值返回该项。
  3. peek(): 查看栈顶项而不移除它。
  4. empty(): 检查栈是否为空。
  5. search(Object o): 返回对象在堆栈中的位置，以 1 为基数。
  6. element(): 检索但不移除栈顶元素。
  7. elements(): 返回此堆栈中元素的迭代器。
  8. size(): 返回此集合中元素的数目。
  9. clear(): 移除此集合中的所有元素。
  10. equals(Object obj): 比较此对象与指定对象的等价性。
  11. hashCode(): 返回此对象的哈希码值。
import java.util.Stack;
public ListNode findFirstCommonNodeByStack(ListNode headA,ListNode headB){
    Stack<ListNode> stackA = new Stack();
    Stack<ListNode> stackB = new Stack();
    while(stackA != null){
        stackA.push(headA);
        headA = headA.next;
    }
    while(headB != null){
        stackB.push(headB);
        headB = headB.next;
    }

    ListNode preNode = null;

    while(stackA.size()>0&&stackB.size()>0){
        if(stackA.peek() == stackB.peek()){
            preNode = stackA.pop();
            stackB.pop();
        }else
        {
            break;
        }

    }
    return preNode;
}

2.判断链表是否为回文序列

2.1基础全部压栈法

public boolean isPalindrome(ListNode head){
    //拷贝原始链表并将其压栈
    ListNode temp = head;
    Stack<Integer> stack = new Stack();
    while(temp != null){
        stack.push(temp.value);
        temp = temp.next;
    }
    //将复制的链表出栈并与原始链表比对,出栈是倒叙，恰好满足回文序列的检测要求
    while(head != null){
        if(head.value != stack.pop()){
            return fasle;
        }
        //值相等则继续检查下一个节点。
        //此处pop()出栈操作，会自动移除栈顶元素，故已经压栈的拷贝链表无需考虑顺延至下一个节点
        head = head.next
    }
    return true;
}

tips：此基础操作有待优化

3.合并有序链表

3.1合并两个有序链表

例子：将两个升序链表合并为一个新的升序链表返回，新链表拼接两个链表所有节点组成。

思路：(1)新建一个链表，分别遍历两个原链表每次选最小节点接到新链表上。

           (2)将一个链表节点拆下，合并至另一个链表上。

若采用（1）代码如下

public ListNode mergeTwoLists(ListNode list1,ListNode list2){
    //新建链表头节点值为-1，不影响排序即可
    ListNode newHead = new ListNode(-1);
    //保留此新建链表头节点并命名为res,newHead更多的作为后续接入口使用
    ListNode res = newHead;
    while(list1 != null&&list2 != null){
        //两链表同长
        if(list1 != null&&list2 != null){
            if(list1.val < list2.val){
                newHead.next = list1;//list1原始表头节点接入newHead
                list1 = list1.next;//失去原表头的list1顺延获得新表头
            }else if(list1.val > list2.val){
                newHead.next = list2;
                list2 = list2.next; 
            }else if(list1.val == list2.val){
                newHead.next = list2;
                list2 = list2.next;
                newHead = newHead.next;//此处暂时更新newHead以便具有相等值的list1头节点也接入进来
                newHead.next = list1;
                list1 = list1.next;
            }newHead = newHead.next;//统一更新接入节点，供下次循环使用
        }
        //到此处本该结束，但考虑到两个要合并的链表有可能长短不一，有一个链表节点会先耗尽，剩下的链表仍要坚持完成接入任务
        else if(list1 != null && list2 == null)//余list1
        {
            newHead.next = list1;
            list1 = list1.next; 
            newHead = newHead.next;
        }
        else if(list2 != null && list1 == null)//余list2
        {
            newHead.next = list2;
            list2 = list2.next; 
            newHead = newHead.next;
        }
    }
    return res.next;//原来的那个值为-1的头节点就扔掉辣
}

写完发现有点臃肿，我们将一个while分解成三个比较好看，如下：

public ListNode mergeTwoLists(ListNode list1,ListNode list2){
    //新建链表头节点值为-1，不影响排序即可
    ListNode newHead = new ListNode(-1);
    //保留此新建链表头节点并命名为res,newHead更多的作为后续接入口使用
    ListNode res = newHead;
    while(list1 != null&&list2 != null){
        //两链表同长
        if(list1.val < list2.val){
            newHead.next = list1;//list1原始表头节点接入newHead
            list1 = list1.next;//失去原表头的list1顺延获得新表头
        }else if(list1.val > list2.val){
            newHead.next = list2;
            list2 = list2.next; 
        }else if(list1.val == list2.val){
            newHead.next = list2;
            list2 = list2.next;
            newHead = newHead.next;//此处暂时更新newHead以便具有相等值的list1头节点也接入进来
            newHead.next = list1;
            list1 = list1.next;
        }newHead = newHead.next;//统一更新接入节点，供下次循环使用        
    }    
    //到此处本该结束，但考虑到两个要合并的链表有可能长短不一，有一个链表节点会先耗尽，剩下的链表仍要坚持完成接入任务
    while(list1 != null && list2 == null)//余list1
    {
        newHead.next = list1;
        list1 = list1.next; 
        newHead = newHead.next;
    }
    while(list2 != null && list1 == null)//余list2
    {
        newHead.next = list2;
        list2 = list2.next; 
        newHead = newHead.next;
    }
   
    return res.next;//原来的那个值为-1的头节点就扔掉辣

}

细看，仍觉不优雅，继续优化直到最简

public ListNode mergeTwoLists(ListNode head1,ListNode head2){
    ListNode prehead = new ListNode(-1);
    ListNode prev = prehead;
    while(head1 != null && head2 != null){
    //等于的情况可合并至不等的一方
        if(head1.val <= head2.val){
            prev.next = list1;
            list1 = list1.next;
        }else{
            prev.next = list2;
            list2 = list2.next;
        }
        prev = prev.next;
    }
    //还剩一个未被合并完，剩下的接上即可，原链表都是升序的这里不会乱序
    prehead.next = list1 == null ? list2 : list1; 
    return prehead.next;
}

这里为化到最简使用了三目运算符——A ? B:C——若事件A为真则取B，不然取C。

3.2合并K个链表

先合并两个，剩下的再逐步与之合并

在mergeTwoLists的基础上构建函数 mergeKLists , 传参 (ListNodes[] lists)

public ListNode mergeKLists(ListNode[] lists){
    ListNode res = null;
    for(ListNode list: lists){
        mergeTwoLists(res,list);
    }
    return res; 
}

3.3链表の移花接木

链表list1,包含n个元素；链表list2,包含m个元素。请你将list1中下标 a 至 b 的节点删除（包括a,b），并在此接入list2。

class Solution {
    public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {

        ListNode preA = list1;
        for(int i=0;i < a-1;i++){
            preA = preA.next;
        }

        ListNode preB = preA;
  
        for(int i=0;i < b-a+2;i++){ 
            preB = preB.next;
        }
        //此处共删去b-a+1个节点，a-1 + b-a+1 + 1=b+1,preB即被切割的list1的后半段链表的头节点. 

        preA.next = list2;//list2头节点接list1前半部分的尾节点
        while(list2.next != null){
            list2 = list2.next;
        }
        list2.next = preB;//list2尾节点接list1后半部分的头节点
        return list1;
        
    }
}

4.双指针

4.1找中间节点

给单链表返回其中间节点（逢双则返回第二个中间节点）

我们使用快慢指针，slow一次走一步，fast一次走两步。fast到达末尾时Slow即中间节点。

 public ListNode middleNode(ListNode head){
     ListNode slow = head;
     ListNode fast = head;
     while(fast != null && fast.next != null){
         slow = slow.next;
         fast = fast.next;
     }
     return slow;

 }

4.2寻找倒数第k个元素

public ListNode getKthFromEnd(ListNode head,int k){
    ListNode fast = head;
    ListNode slow = head;
    //本题从1开始计数，fast先走k步到第k+1位。然后和slow一起往后遍历，我们要fast走到末尾null节点，这时我们往前数k个数即找到倒数第k个节点，即slow.
    while(fast != null && k > 0){
        fast = fast.next;
        k--;
    }
    while(fast != null){
        fast = fast.next;
        slow = slow.next;
    }
    return slow;
}

4.3旋转链表

给出链表的头节点，旋转链表，将每个节点向右移动k个位置。

两种思路：

1.整个链表反转，再将前k和n-k两部分分别反转，反转链表。

2.双指针找到倒数k的位置，再将两链表拼接：

public ListNode rotateRight(ListNode head,int k){
    if(head == null || k == 0){
        return head;
    }
    ListNode slow = head;
    ListNode fast = head;
    ListNode temp = head;//记录原链表
    int len = 0;
    //先统计链表元素个数
    while(head != null){
        head = head.next;
        len++;
    }
    //向右移动k个单位，若k是len的整数倍，那么相当于没有旋转.取余而非除以是考虑到k>len
    if(k % len == 0){
        return temp;
    }
    while((k%len)>0){
        k--;
        fast = fast.next;
    }
    while(fast.next != null){
        fast = fast.next;
        slow = slow.next;
    }

    //此时fast为尾部节点，slow为要断开的地方，（此处指向右位移k位后的链表尾节点）
    ListNode res = slow.next;//确定头
    slow.next = null;//尾接null
    fast.next = temp;//中间拼接
    //以上三步是旋转后链表的拼接
    return res;    
    
}

5.链表删除专题

5.1删除特定节点

删除某特定值的节点

public ListNode removeElements(ListNode head,int val){
    ListNode dummyHead = new ListNode(0);
    dummyHead.next = head;
    ListNode cur = dummyHead;
    while(cur.next != null){
        if(cur.next.val == val){
            cur.next == cur.next.next;//跳过即可删除cur.next,cur还在的
        }else{
            cur = cur.next;//否则遍历
        }
    }
    return dummyHead.next;
}

5.2删除倒数第N个节点

算链表长：

public ListNode removeNthFromEnd(ListNode head,int n){
    ListNode dummyHead = new ListNode(0);
    dummyHead.next = head;
    int length = getLength(head);
    ListNode cur = dummyHead;
    //找到倒数第n个节点
    for(int i;i<length-n+1;++i){
        cur = cur.next;
    }
    //找到就删掉
    cur.next = cur.next.next;
    return dummyHead.next;

    public int getLength(ListNode head){
        int length = 0;
        while(head != null){
            ++length;
            head = head.next;
        }
        return length;
    }
}

双指针：

public ListNode removeNthFromEnd(ListNode head,int n){
    ListNode dummyHead = new ListNode(0);
    dummyHead.next = head;
    ListNode first = head;
    ListNode second = dummyHead;
    for(int i=0; i<n;++i){
        first = first.next;
    }
    while(first != null){
        first = first.next;
        second = second.next;
    }
    second.next = second.next.next;
    return dummyHead.next;
}

5.3删除重复元素

保留一个重复元素/删除所有重复元素（假设给定链表排好序的）

若保留：

public ListNode deleteDuplicates(ListNode head){
    if(head == null){
        return head;
    }
    ListNode cur = head;
    while(cur.next != null){
        if(cur.val == cur.next.var){
            cur.next = cur.next.next;
        }else{
            cur = cur.next;
        }
    }
    return head;
}

若不保留：

public ListNode deleteDuplicates(ListNode head){
    if(head == null){
        return head;
    }
    ListNode dummy = new ListNode(0,head);//参数里的head说明dummy节点将被连接到head，无需 dummy.next = head  
    ListNode cur = dummy;//与保留一个重复元素的情况加以思考并区分
    while(cur.next != null &&cur.next.next != null){
        if(cur.next.val == cur.next.next.val){
            int x = cur.next.val;
            while(cur.next != null &&cur.next.val == x){
                cur.next = cur.next.next;
            }
        }
        else{
            cur = cur.next;
        }
    }
        return dummy.next;
}

6.回顾第一个公共子节点问题

使用栈或者集合都需要开辟  O(n）空间，我们尝试只用一两个变量解决.

6.1拼接两个字符串

public ListNode findFirstCommonNode(ListNode pHead1,ListNode pHead2){
    if(pHead1==null || pHead2==null){
        return null
    }
    ListNode p1=pHead1;
    ListNode p2=pHead2;
    while(p1!=p2){
        p1=p1.next;
        p2=p2.next;
        if(p1!=p2){//避免序列不存在交集时陷入死循环
            if(p1==null){
                p1=pHead2;
            }
            if(p2==null){
                p2=pHead1;
            }
        }

    }
    return p1;
}

6.2差和双指针

长的链表先走 一个链表长度差值，然后两个链表同时往前走，节点一样时即找到公共节点。

public ListNode findFirstCommonNode(ListNode pHead1,ListNode pHead2){
      if(pHead1==null || pHead2==null){
        return null
    }
    ListNode current1=pHead1;
    ListNode current2=pHead2;
    int l1=0,l2=0;
    while(current1!=null){
        current1=current1.next;
        l1++;
    }
     while(current2!=null){
        current2=current2.next;
        l2++;
    }

    current1=pHead1;
    current2=pHead2;
    int sub=l1>l2?l1-l2:l2-l1 ;
    if(l1>l2){
        int a=0;
        while(a<sub){
            current1=current1.next;
            a++;
        }
    }
    if(l1<l2){
        int a=0;
        while(a<sub){
            current2=current2.next;
            a++;
        }
    }
    while(current1!=current2){
        current1=current1.next;
        current2=current2.next;
    }

    return current1;
}

给个offer嘛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
10道经典链表面试题
xaiobit_hl的博客
05-18 3732
目录 1.删除链表中等于给定值val的所有节点 2.反转一个单链表 3.给定一个带有头结点head的非空单链表，返回链表的中间结点。如果有两个中间结点，则 返回第二个中间结点 4.输入一个链表，输出该链表中倒数第k个结点 5.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所 有节点组成的 6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的 结点之前 7. 链表的回文结构 8. 输入两个链表，找出它们.........
数据结构 十一道链表相关面试题,牛客 LeetCode,在线OJ题
wwzzzzzzzzzzzzz的博客
11-07 595
目录 链表面试题: 第一题 :移除链表元素 解题思路: 画图解析: 具体代码: 第二题 :反转链表 解题思路: 画图解析: 具体代码: 第三题 :链表的中间结点 解题思路: 画图解析: 具体代码: 第四题 :链表中倒数第k个结点 解题思路: 画图解析: ​具体代码: 第五题 :合并两个有序链表 解题思路: 画图解析: ​具体代码: 第六题 :链表分割 解题思路: 画图解析: ​具体代码: 第七题 :删除链表中重复的结点 解题思路: ...
链表常见面试题( 建议收藏！！)
一朵花花
08-31 3678
链表面试题????1.删除链表中等于给定值 val 的所有节点2.二级目录3.三级目录 1.删除链表中等于给定值 val 的所有节点 题目： 题目链接： https://leetcode-cn.com/problems/remove-linked-list-elements/. 思考： 用tmp记录当前节点，若tmp 的下一个节点不为空且下一个节点的节点值等于给定的 val，则需要删除tmp的下一个节点 2.二级目录 3.三级目录 ...
链表题大全 10道题【10道经典链表题帮助你掌握链表】
蓝天it（让亿万孩子在蓝天下共享优质教育）
08-23 103
l1 = l2;break;l1 = l2;continue;l1 = l2;
链表：题集
weixin_54342360的博客
03-17 979
链表相关的面试题：链表的转置、寻找中间节点、判断链表是否有环等
面试高频算法习题精讲.rar
12-29
在准备IT行业的面试时，掌握高频算法是至关重要的。这些算法不仅体现了候选人的逻辑思维能力，也是解决问题的关键技能。"面试高频算法习题精讲"这个压缩包文件显然是为了帮助应聘者集中精力学习那些在面试中经常出现...
LeetCode高频算法面试题,含解题思路及代码实现
02-17
以上是LeetCode高频算法面试题的一些主要知识点。通过深入学习和实践，你可以提升自己的算法能力，为面试做好充分准备。解题思路和代码实现的分享可以帮助你更好地理解和应用这些算法，从而在实际工作中解决复杂的...
Python实现数据结构与算法——反转链表
12-21
反转链表是数据结构与算法领域中的一个经典问题，它要求我们改变链表节点的指向，使得原本顺着一个方向的链表变成逆序。在这个问题中，我们可以采用两种方法来解决：迭代和递归。 首先，让我们详细讲解迭代的解题...
C语言链表相关面试题.zip
最新发布
03-13
C语言链表相关的面试题在软件开发领域的面试中是非常常见的，这是因为链表作为一种基本的数据结构，对于理解数据结构、算法以及内存管理等方面有着重要的作用。以下是一些关于C语言链表的面试题及其详细解释。 1. ...
链表面试题_链表_面试题_cow3cm_数据结构_
09-30
链表是一种基础且重要的数据结构，在计算机科学特别是数据结构...同时，熟悉常见的链表面试题，有助于提升解决实际问题的能力。通过深入学习和实践，我们可以掌握如何有效地利用链表这一数据结构来优化算法和程序设计。
常见的链表面试题大汇总
09-05
常见的链表面试题大汇总： 1，创建一个链表结点 2，遍历链表中的所有结点 3，倒序打印链表 4，往链表末尾添加结点 5，往链表前端添加结点, 6，获取链表的节点数目 7，销毁链表 8，求链表中倒数第K个节点 9，反转链表 10，查找链表中间节点 11，判断链表是否有环 12，判断链表是否有环，并返回环上的节点数目
链表经典题目
qq_33253721的博客
05-19 505
一、虚拟头结点 题目203. 移除链表元素. 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 在链表中想要删除一个节点，让节点（待删除节点的上一个节点）的next指针指向下下个节点即可（node.next = node.next.next）。 除了正常的删除，我们还需要考虑特殊的情况，比如，删除的是头节点该怎么办？ 第一种方式：直接使用原来的链表进行删除操作 即将头节点向后移动一位即可 然后再将原本的头节点删
链表经典面试题
开心的博客
09-07 401
删除链表中等于给定值 val 的所有节点 public ListNode removeElements(ListNode head, int val) { if(head == null){ return null; }else{ ListNode cur = head; ListNode prev = head; while(cur!=null){ .
链表常见面试题讲解（一）
qq_43780610的博客
04-21 167
链表面试题讲解移出链表元素 移出链表元素 题目： 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 题目链接：移出链表元素——来试试 其实移出链表元素就是删除对应值的链表节点，操作无非记录要删除节点的上一个节点，使得这个节点指向要删除的节点的下一个节点，代码演示： //preNode节点是要删除节点的上一个节点 //toDelNode节点是要删除的节点 preNode.next = toDelNode.n
【程序员面试宝典】链表相关面试题
double_happiness的博客
07-04 357
1、链表中的第k个节点 题目描述： 输入一个链表，输出该链表中倒数第k个结点struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } }; ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
链表相关面试题（一）
观赏的博客
03-26 302
当我对指针的使用感到很简单的时候，链表给了我一记重击。 在面试中，最经常被提及的就是链表，因为它简单，但又因为需要对指针进行操作，凡是涉及到指针的，都需要我们具有良好的编程基础才能确保代码没有任何错误。 所以，整理了一些面试题，特别记录下来。 注：本文是对上一篇文章的补充。（http://blog.csdn.net/qq_35524916/article/details/662962
链表常见面试题
weixin_45785104的博客
10-25 223
注：本文章练习题来自牛客和LeetCode，分享的是自己的练习总结 1.给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。1.先不考虑头结点，因为优先考虑头结点值会产生循环处理较为复杂 2.先进行处理后面的普通的结点，如果该结点的值与val相等，则删除，若不相等则继续处理下一个结点，直到处理完所有的结点 3.再处理头结点 /** * Definition for singly-linked list....
常见的链表面试题大汇总：
mengni123321的专栏
09-05 859
常见的链表面试题大汇总： 源代码下载链接 1，创建一个链表结点 2，遍历链表中的所有结点 3，倒序打印链表 4，往链表末尾添加结点 5，往链表前端添加结点,6，获取链表的节点数目 7，销毁链表 8，求链表中倒数第K个节点 9，反转链表 10，查找链表中间节点11，判断链表是否有环 12，判断链表是否有环，并返回环上的节点数目 13，判断链表是否有环，并返回环上的入口节点 1
链表面试题
你又来看我了，一起学习吧
09-11 4314
前言： 在面试中，最经常被提及的就是链表，，但又因为需要对指针进行操作，凡是涉及到指针的，都需要我们具有良好的编程基础才能确保代码没有任何错误。 链表是一种动态的数据结构，因为在创建链表时，我们不需要知道链表的长度，当插入一个结点时，只需要为该结点分配内存，然后调整指针的指向来确保新结点被连接到链表中。所以，它不像数组，内存是一次性分配完毕的，而是每添加一个结点分配一次内存。正是因为这点，所以...
二元查找树转排序双向链表——程序员面试题解析
其中一道典型的面试题是关于将二元查找树（Binary Search Tree, BST）转换为排序的双向链表。这道题目要求在不创建新节点的情况下，仅通过调整原有节点的指针，将一棵BST转换成一个有序的双向链表。 二元查找树是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值