脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → java链表的常见面试算法题

java链表的常见简单面试算法题详解

 更新时间：2025年01月07日 09:24:07   作者：石以砥焉，以锐为利  
文章总结：本文主要介绍了单链表的基本操作,包括头插法、尾插法、链表翻转、链表成环判断、成环位置判断、成环长度判断,以及有序链表的合并,通过实例和代码示例,详细讲解了每种操作的原理和实现方法

java链表的常见面试算法题

头插法、尾插法

头插法：先待插入指向头结点的next，后头结点的next指向待插入。

尾插法：借助尾指针，直接插入

 /**
     * 头插法
     * @param head
     * @return
     */
    public static Node head_insert(Node head, int t){
        Node node=new Node(t);
        node.setNext(head.getNext());
        head.setNext(node);
        return head;
    }

    /**
     * 尾插法
     * @param head
     * @return
     */
    public static Node tail_insert(Node head,int t){
        Node tail=head;
        Node target=new Node(t);
        while (tail.getNext()!=null){
            tail=tail.getNext();
        }
        tail.setNext(target);
     return head;
    }
}

单链表翻转

力扣：LCR 024. 反转链表

将翻转前的链表记pre，翻转后的记next（也是head）。结点依次翻转。

class Solution {
    public ListNode reverseList(ListNode head) {
     ListNode pre=null;ListNode next=null;
     while (head!=null){
         next=head.next;
         head.next=pre;
         pre=head;
         head=next;
     }
     return pre;
    }
}

链表成环判断

力扣：141. 环形链表

定义两个指针slow、fast，slow走一步，fast走两步遍历链表。相遇就有环

public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode slow=head;
        ListNode fast=head;
        while(fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
            if(slow==fast){
              return true;
            }
        }
        return false;

    }
}

链表成环位置判断

力扣：LCR 022. 环形链表 II

（1）定义一个A指针（指向开始点A）、B指针（指向相遇点B）。以相同速度移动，相遇点就是环的入口。

public class Solution {
    public ListNode detectCycle(ListNode head) {
        Boolean result=false;
        ListNode slow=head;
        ListNode fast=head;
        while (slow!=null&&fast!=null&&fast.next!=null){
           slow=slow.next;
           fast=fast.next.next;
           if(slow==fast){
               result=true;
               break;
           }
        }
        if(result==false){
         return null;
        }
        slow=head;
        while (slow!=fast){
            slow=slow.next;
            fast=fast.next;
        }
        return slow;
    }
}

（2）为什么慢指针和快指针相遇时一定没走完一圈？

将环平铺展开，假设慢指针走完一圈了，快指针走两圈的距离。在下图中看出快指针已经超过了慢指针，中途一定有相遇的瞬间。

链表成环长度判断

在上一题找到环入口的前提下，再定义一个指针，绕一圈环并记数。

有序链表的合并

力扣：21. 合并两个有序链表

定义一个pre指针，始终指向已经排好序的链表尾结点。定义一个虚拟节点作为pre的初始节点。

依次遍历两个链表取出小的那个结点作为pre的下一个结点。

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
     ListNode head=new ListNode(0);
     ListNode pre=head;
     while(list1!=null&&list2!=null){
        if(list1.val<list2.val){
          pre.next=list1;
          pre=list1;
          list1=list1.next;
        }else{
          pre.next=list2;
          pre=list2;
          list2=list2.next;
        }
     }
     if(list1==null){
     pre.next=list2;
     }else{
        pre.next=list1;
     }
     return head.next;
   }
}

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

相关文章

最新评论