【牛客网刷题记录】【java】链表

Hundred billion

已于 2024-09-26 17:51:27 修改

阅读量659

点赞数 29

文章标签： java 链表开发语言

于 2024-09-23 18:20:29 首次发布

本文链接：https://blog.csdn.net/FQY__/article/details/141999733

版权

（1）反转链表

链接
可以说是最经典的链表题目之一，并且很多人经常会记不得怎么做。
但大致思路是比较简单的，重点就是如何用指针对链表进行反转的同时还不能丢失链表。不可避免的就是需要一个指针指向已经反转的部分（pre），另一个是指向仍未反转的部分（cur)。
例如节点是A->B->C, pre指向A，cur指向B，每次用cur向后移动（C），代表待反转的变少，pre要移动到B，并且将B的next指向A，这就需要多一个tmp指针。

JAVA：

public class Solution {
    public ListNode ReverseList (ListNode head) {
        ListNode pre=null, cur=head, tmp=null;

        while(cur!=null){
            tmp=cur;
            cur=cur.next;
            tmp.next=pre;
            pre=tmp;
        }

        return tmp;
    }
}

（2）链表内指定区间反转

链接

最简单的方法就是，将需要反转的部分提出，反转后再放回去。

public class Solution {
    /**
     * 
     * @param head ListNode类 
     * @param m int整型 
     * @param n int整型 
     * @return ListNode类
     */
       //说明：方便理解，以下注释中将用left，right分别代替m,n节点 

    public ListNode reverseBetween (ListNode head, int m, int n) {
             //设置虚拟头节点
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;

        ListNode pre = dummyNode;
        //1.走left-1步到left的前一个节点
        for(int i=0;i<m-1;i++){
            pre = pre.next;
        }

        //2.走roght-left+1步到right节点
        ListNode rigthNode = pre;
        for(int i=0;i<n-m+1;i++){
            rigthNode = rigthNode.next;
        }

        //3.截取出一个子链表
        ListNode leftNode = pre.next;
        ListNode cur = rigthNode.next;

        //4.切断链接
        pre.next=null;
        rigthNode.next=null;

        //5.反转局部链表
        reverseLinkedList(leftNode);

        //6.接回原来的链表
        pre.next = rigthNode;
        leftNode.next = cur;
        return dummyNode.next;
    }
    //反转局部链表
    private void reverseLinkedList(ListNode head){
        ListNode pre = null;
        ListNode cur = head;
        while(cur!=null){
            //Cur_next 指向cur节点的下一个节点
            ListNode Cur_next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = Cur_next ;
        }
    }
}

（3）合并两个排序的列表

链接
说实话，这题我认为递归是最清晰且好理解的。
两个链表的元素怎么衔接节点大致有如下考虑：例如有a和b节点，a小于b并不能说明a后面要衔接b，因为a的后一个值可能大于b。因此要判断到a小于b且a后的值大于b。同时，如果出现了一个链表已经遍历完后，可以直接加在后面（类似于归并排序）。
但这样的问题就是代码会比较冗余，因为需要判断现在谁是更小的节点。如果用递归，则可以很自然的处理那个节点的值更小的情况。我们每次判断当前的a和b节点谁更小，将小的值的下一个节点和大的节点放入递归即可。

public ListNode Merge (ListNode pHead1, ListNode pHead2) {
        // 特判为空
        if(pHead1==null || pHead2==null){
            return pHead1==null? pHead2 : pHead1;
        }

        if(pHead1.val<=pHead2.val){
            pHead1.next=Merge(pHead1.next, pHead2);
            return pHead1;
        }else{
            pHead2.next=Merge(pHead1, pHead2.next);
            return pHead2;
        }

    }

或者使用迭代来写，也比较简单。创建一个dummy节点，将剩余的节点续在dummy后面：

 public ListNode Merge (ListNode pHead1, ListNode pHead2) {
        // 特判为空
        if (pHead1 == null || pHead2 == null) {
            return pHead1 == null ? pHead2 : pHead1;
        }

        ListNode dummy = new ListNode(0);
        ListNode p1 = pHead1, p2 = pHead2, tmp=dummy;
       
        while(p1!=null&&p2!=null){
            if(p1.val<p2.val){
                tmp.next=p1;
                p1=p1.next;
            }else{
                tmp.next=p2;
                p2=p2.next;
            }
            tmp=tmp.next;
        }

        tmp.next = (p1 == null) ? p2 : p1;
       
        return dummy.next;
        
    }

（4）合并k个已排序的链表

链接
最开始的思路就像是做归并（多路归并，常用于磁盘），用一个tmpList存储lists里的子链表的头指针，然后再每次选出最小的指针，将该指针指向的内容挂到dummy的后面。这样的思路很类似与归并排序。
在这里插入图片描述
而这样的操作可以进一步简化，不需要加入tmplist：这是因为表面上看lists是一个arraylist，每个元素是一串链表，但实际上每个元素存储的还是指针，而后续的链表节点都是由指针连接起来的。因此lists和我们设想的tmplist其实是一样的。
我们要做的是：每次从list的子链表选一个最小的，用minNode这个指针进行表示。添加到res后，minNode向后移动。这里的set方法是更新 lists 中对应链表的当前节点。

public ListNode mergeKLists(ArrayList<ListNode> lists) {
    if (lists == null || lists.size() == 0) {
        return null;
    }

    ListNode dummy = new ListNode(0);
    ListNode res = dummy;
    int len = lists.size();

    while (true) {
        ListNode minNode = null;
        int minFlag = -1;

        // 找到当前最小节点
        for (int i = 0; i < len; i++) {
            ListNode node = lists.get(i);
            if (node != null && (minNode == null || node.val < minNode.val)) {
                minNode = node;
                minFlag = i;
            }
        }

        // 如果所有链表都遍历完了，跳出循环
        if (minNode == null) {
            break;
        }

        // 将最小节点添加到结果链表中
        res.next = minNode;
        res = res.next;

        // 更新对应链表的当前节点
        lists.set(minFlag, minNode.next);
    }

    return dummy.next;
}

顺便说一下：

lists.get(minFlag)=lists.get(minFlag).next;

这样的操作是不合法的。代码本意是想表达将minFlag位置的内容（即指针）指向下一个元素，但是在Java中，方法调用的结果是一个值，而不是一个可以赋值的左值，即lists.get(minFlag) 是一个方法调用的结果，它返回一个 ListNode 对象的引用，但这个引用本身不是一个可以赋值的变量。
为了更新 ArrayList 中的元素，你需要使用 ArrayList 的 set 方法。set 方法允许你指定索引并更新该索引处的元素。例如：

lists.set(minFlag, lists.get(minFlag).next);

上面的代码可以完成要求，但每次需要找到子列表的最小值，这就增加了操作，提高了时间复杂度。我们可以考虑用最小堆（优先队列）来优化：

public ListNode mergeKLists(ArrayList<ListNode> lists) {
        if (lists == null || lists.size() == 0) {
            return null;
        }

        ListNode dummy = new ListNode(0);
        ListNode res = dummy;

        // 使用优先队列（最小堆）来优化查找最小节点的过程
        PriorityQueue<ListNode> pq = new PriorityQueue<>((a, b) -> a.val - b.val);
        //(a, b) -> a.val - b.val：这是一个Lambda表达式，用于定义比较器。

        // 初始化优先队列
        for (ListNode node : lists) {
            if (node != null) {
                pq.add(node);
            }
        }

        while (!pq.isEmpty()) {
            ListNode minNode = pq.poll();
            res.next = minNode;
            res = res.next;

            if (minNode.next != null) {
                pq.add(minNode.next);
            }
        }

        return dummy.next;
    }

对于lambda表达式：在Java中，Comparator 接口用于定义对象的比较规则。PriorityQueue 使用这个比较器来确定元素的顺序。比较器的 compare 方法通常返回一个整数值，用于表示两个对象的相对顺序：

负值：表示第一个对象小于第二个对象。
零：表示两个对象相等。
正值：表示第一个对象大于第二个对象。

(5) 判断链表中是否有环

链接
很经典的题目，用快慢指针可以很快的得到是否成环。如果成环，快指针肯定会追上慢指针。

public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode fast=head, slow=head;

        while(fast!=null && fast.next!=null){
            slow = slow.next;
            fast = fast.next.next;
            if(fast==slow){
                return true;
            }
        }

        return false;
    }
}

（6）链表中环的入口结点

链接
上面的题目的进阶，这次还要判断入口在哪里。因为双指针相遇的地方不会是入口，因此直接返回slow是不对的。这里需要一些数学推理：
在这里插入图片描述
这里设slow和fast走的距离是Lslow和Lfast，环之前的长度为a，环长度为b，换入口到相遇地点长度为x。那么则有：

Ls=a+x
Lf=2a+2x=a+b+x
可以得到a=b-x，也就是新的指针（ptr）从头开始走到入口和slow继续走到入口的距离一样，因此第二个循环则是针对这两个指针。

public ListNode EntryNodeOfLoop(ListNode pHead) {
        ListNode slow=pHead, fast=pHead, ptr=pHead;
        boolean flag=false;

        while(fast!=null && fast.next!=null){
            slow=slow.next;
            fast=fast.next.next;
            if(slow==fast){
                flag=true;
                break;
            }
        }
		// 判断是否有环，如果没有环，则返回null
        if(flag==false){
            return null;
        }
        
        while(true){
            if(slow==ptr){
                break;
            }
            slow=slow.next;
            ptr=ptr.next;
        }
        return slow;
    }

（7）链表中倒数最后k个结点

链接
也算快指针的做法，先让快指针走k个（有dummy节点），之后再让slow和fast同时走，即可找到倒数的节点。注意输入样例会有超出链表长度的输入，加入判断语句即可。

public ListNode FindKthToTail (ListNode pHead, int k) {
        // write code here
        ListNode dummy=new ListNode(-1);
        dummy.next=pHead;
        ListNode fast=dummy, res=pHead;

        for(int i=0; i<k; i++){
            fast=fast.next;
            if(fast==null){
                return null;
            }
            
        }

        while(fast.next!=null){
            fast=fast.next;
            res=res.next;
        }

        return res;
    }

（8）两个链表的第一个公共结点

链接
在这里插入图片描述
也是数学推理，假设第一个链表到交点之前的长度为a，第二个链表到交点之前的长度为b，公共长度为x。因此如果指针遍历完自己的链表，再跳转到另一个链表遍历，那么两个指针一定会在交点相遇。

a+x+b=b+x+a
这样可以得到代码：

public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        ListNode ptr1=pHead1, ptr2=pHead2;

        while(ptr1!=ptr2){
            ptr1 = (ptr1 != null) ? ptr1.next : pHead2;
            ptr2 = (ptr2 != null) ? ptr2.next : pHead1;

        }

        return ptr1;
    }

（9）链表相加（2）

链接
思路还是比较好想，用之前链表反转的代码可以将两个链表反转，这也再相加即可简化操作。

public ListNode addInList (ListNode head1, ListNode head2) {
        // write code here
        if (head1 == null) {
            return head2;
        } else if (head2 == null) {
            return head1;
        }

        // 反转h1链表
        head1 = reverse(head1);
        // 反转h2链表
        head2 = reverse(head2);
        // 创建新的链表头节点
        ListNode head = new ListNode(-1);
        ListNode nHead = head;
        // 记录进位的数值
        int tmp = 0;
        while (head1 != null || head2 != null) {
            // val用来累加此时的数值（加数+加数+上一位的进位=当前总的数值）
            int val = tmp;
            // 当节点不为空的时候，则需要加上当前节点的值
            if (head1 != null) {
                val += head1.val;
                head1 = head1.next;
            }
            // 当节点不为空的时候，则需要加上当前节点的值
            if (head2 != null) {
                val += head2.val;
                head2 = head2.next;
            }
            // 求出进位
            tmp = val / 10;
            // 进位后剩下的数值即为当前节点的数值
            nHead.next = new ListNode(val % 10);
            // 下一个节点
            nHead = nHead.next;

        }
        // 最后当两条链表都加完的时候，进位不为0的时候，则需要再加上这个进位
        if (tmp > 0) {
            nHead.next = new ListNode(tmp);
        }
        // 重新反转回来返回
        return reverse(head.next);
    }

    static ListNode reverse(ListNode head) {
        ListNode cur = head, tmp = null, pre = null;

        while (cur != null) {
            tmp = cur;
            cur = cur.next;
            tmp.next = pre;
            pre = tmp;
        }

        return pre;
    }

（10）单链表的排序

链接

很简单，时间复杂度和空间复杂度的要求正好可以申请一个List，因此直接排序再赋值回链表即可。

 public ListNode sortInList (ListNode head) {
        // write code here
        List<Integer> tmp = new ArrayList<>();
        for(ListNode p=head; p!=null; p=p.next){
            tmp.add(p.val);
        }
        Collections.sort(tmp);

        int i=0;
        for(ListNode p=head; p!=null; p=p.next, i++){
            p.val=tmp.get(i);
        }
        return head;
    }

（11）判断一个链表是否为回文结构

链接

public boolean isPail (ListNode head) {
        // write code here
        if(head==null){
            return true;
        }

        List<Integer> t=new ArrayList<>();

        for(ListNode p=head; p!=null; p=p.next){
            t.add(p.val);
        }
        int len=t.size();
        for(int i=0; i<len/2; i++){
            if(!t.get(i).equals(t.get(len - i - 1))){
                return false;
            }
        }
        return true;
    }

注意，如果写成：

for(int i=0; i<len/2; i++){
    if(t.get(i)!=t.get(len-i-1)){
        return false;
    }

这是错误的，因为Java中的!=运算符用于比较基本数据类型的值，而对于对象（包括Integer对象），它比较的是对象的引用，而不是对象的值。t.get(i)和t.get(len-i-1)返回的是Integer对象。因此用equal方法来进行比较值。

这种方法需要额外空间，我们也可以用双指针+反转链表来节约空间：
在这里插入图片描述
先用快慢指针找到中间点，并且沿着中间点翻转链表，这也left和right相向而行并且检查即可。

 public boolean isPail (ListNode head) {
        // write code here
        if(head==null){
            return true;
        }
        // 快慢指针找中间点
        ListNode fast=head, slow=head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        // 后段进行链表反转
        ListNode pre = null,tmp=null;
        while (slow != null) {
            tmp=slow;
            slow=slow.next;
            tmp.next=pre;
            pre=tmp;
        }
        // tmp即为最右端
        ListNode left = head;
        ListNode right = pre;
        while (right != null) {
            if (left.val != right.val) {
                return false;
            }
            left = left.next;
            right = right.next;
        }

        return true;
    }

（12）链表的奇偶重排

链接
最简单直白的方法就是用List存储链表的奇偶位置的内容，再进行重新排列（注意不需要排序），就算很简单的模拟。但是这种方法就需要额外的空间存储元素，并且有点傻傻的。
高级一些的方法也很简单，只需要跳着进行链接即可。循环的条件是有一个指针为null即停止，否则会出现访问空的情况。

public ListNode oddEvenList (ListNode head) {
        // write code here
        if (head == null) {
            return null;
        }
        ListNode odd = head; // 奇数位节点链表的头
        ListNode even = head.next; // 偶数位节点链表的头
        ListNode evenHead = even; // 保存偶数位节点链表的头，以便最后连接

        while (even != null && even.next != null) {
            odd.next = even.next; // 将奇数位节点连接到下一个奇数位节点
            odd = odd.next; // 移动到下一个奇数位节点
            even.next = odd.next; // 将偶数位节点连接到下一个偶数位节点
            even = even.next; // 移动到下一个偶数位节点
        }

        odd.next = evenHead; // 将奇数位节点链表和偶数位节点链表连接起来
        return head;
        
    }

（13) 删除有序链表中重复的元素-I

链接

很简单，当前元素的值与后面的元素的值相同，则跳过后一个元素即可。

public ListNode deleteDuplicates (ListNode head) {
        // write code here
        if(head==null||head.next==null){
            return head;
        }
        ListNode p=head;
        while(p.next!=null){
            if(p.val==p.next.val){
                p.next=p.next.next;
            }else{
                p=p.next;
            }
        }

        return head;

    }

（14）删除有序链表中重复的元素-II

链接
做出了不是很麻烦，就是如果遇到当前值等于后一个节点的值的情况，就用n记录当前的值，并且不断循环后移指针，指针指向的值不等于n为止。但是这样写代码会不太优雅：
在这里插入图片描述

public ListNode deleteDuplicates (ListNode head) {
        // write code here
        if(head==null||head.next==null){
            return head;
        }
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode pre=dummy, cur=head;
        while(cur.next!=null){
            if(cur.val==cur.next.val){ // 出现重复
                int n=cur.val;
                while(n==cur.val){
                    cur=cur.next;
                    if(cur==null){
                        pre.next=cur;
                        return dummy.next;
                    }
                }
                pre.next=cur;
            }else{ //不重复，则直接向后
                cur=cur.next;
                pre=pre.next;
            }
        }

        return dummy.next;
    }

修改一下代码得到更优雅的版本：

public ListNode deleteDuplicates(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }

    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode pre = dummy;
    ListNode cur = head;

    while (cur != null) {
        // 移动cur指针直到找到不同的节点
        while (cur.next != null && cur.val == cur.next.val) {
            cur = cur.next;
        }
        // 如果pre的下一个节点就是cur，说明没有重复
        if (pre.next == cur) {
            pre = pre.next;
        } else {
            // 否则跳过重复的节点
            pre.next = cur.next;
        }
        cur = cur.next;
    }

    return dummy.next;
}