代码随想录-Day4:Leetcode:24. 两两交换链表中的节点

灰太狼家的小鸭子

已于 2023-02-18 13:46:48 修改

阅读量130

点赞数

分类专栏： Leetcode 文章标签：数据结构链表

于 2023-02-06 19:12:34 首次发布

本文链接：https://blog.csdn.net/JEREMY_GYJ/article/details/128906749

版权

Leetcode 专栏收录该内容

54 篇文章 0 订阅

订阅专栏

24：两两交换链表

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

模拟：模拟的思路，设置虚拟头节点。然后设置两个临时的节点保存1和3 节点。然后按照2->1 ->3的顺序进行模拟就行了。判断终止的条件就是cur.next !=null && cur.next.next!=null。

class Solution {
   public ListNode swapPairs(ListNode head) {

        ListNode dummyHead = new ListNode();
        dummyHead.next=head;//设置虚拟头节点；
        ListNode cur=dummyHead;//cur指向头节点
        
        while (cur.next !=null && cur.next.next !=null){//循环终止的条件；
            ListNode tempNode1=cur.next;//存储第一个节点
            ListNode tempNode2=cur.next.next.next;//存储第三个节点
            
            cur.next=cur.next.next;
            cur.next.next=tempNode1;//第一个1节点；
            cur.next.next.next=tempNode2;//第二个2节点
            
            //交换完后cur 后移两个节点；
            
            cur= cur.next.next;
        }

        return dummyHead.next; //返回头节点；
    }
}

递归的方式：思想是类似的；

public class swapListNode02_24 {

    public ListNode swapPairs(ListNode head) {

        ListNode dummy = new ListNode();
        dummy.next=head;
        ListNode cur=dummy;
        return swap(dummy,cur);

    }

    public ListNode swap(ListNode dummy,ListNode cur){
        if(cur.next ==null || cur.next.next ==null)//递归出口；返回虚拟头节点的下一个元素；
            return dummy.next;
        ListNode temp1=cur.next;//存储第一个节点；
        ListNode temp2= cur.next.next.next;//存储第三个节点；
        cur.next=cur.next.next;
        cur.next.next=temp1;
        temp1.next=temp2;
        cur=cur.next.next;
        return swap(dummy,cur);
    }

}

19. 删除链表的倒数第 N 个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[1]

class Solution {
    //让fast指针和slow 指针相差n+1,slow刚好指向要删除节点的前一个节点；
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyHead = new ListNode();
        dummyHead.next=head;
        ListNode fast=dummyHead;
        ListNode slow=dummyHead;


        for(int i=0;i<n;i++){
            fast=fast.next;
        }
        fast=fast.next;//此时slow和fast相差n+1个位置；
        
        while (fast!=null){
            fast=fast.next;
            slow=slow.next;
        }
        slow.next=slow.next.next;//删除倒数第n元素，slow直接指向 倒数第n-1个元素；
        return dummyHead.next;
    }
}

面试题 02.07. 链表相交

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '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
输出：Intersected at '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 。

解析1：先求出AB链表的长度，比较谁比较长，谁就先移动sub_length的长度；然后再遍历剩下的长度，返回相交的点即可。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int A_len=0;
        int B_len=0;
        ListNode curA = new ListNode();
        ListNode curB=new ListNode();
        curA=headA;
        curB=headB;
        //计算出A B链表的长度；
        while (curA!=null){ 
            curA=curA.next;
            A_len++;
        }

        while (curB !=null){
            curB=curB.next;
            B_len++;
        }
        curA=headA;
        curB=headB;
        if (A_len==B_len) {   
           for (int i=0;i<A_len;i++){
               if (curA ==curB){
                  return curA;
               }
               curA=curA.next;
               curB=curB.next;
           }
        }else if(A_len >B_len){
            int dislength=A_len-B_len;
            //A链表移动到与B链表相同的位置；
            for (int i=0;i<dislength;i++){
                curA=curA.next;
            }
            //从B链表开始遍历；
            for (int j=0;j<=B_len;j++){
                if (curA==curB) {
                    return curA;
                }
                curA=curA.next;
                curB=curB.next;
            }
        }else{     
            int dislength=B_len-A_len;
            for (int i=0;i<dislength;i++){
                curB=curB.next;
            }
            
            for(int j=0;j<A_len;j++){
                if (curA==curB)
                    return curA;
                curA=curA.next;
                curB=curB.next;
            }
        }
        return null;
    }
}

解析2：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA=headA;
        ListNode curB=headB;
        
        //如果有公共的解的话 c是公共的长度： A =a+(b-c) ,B =b+ (a-c)
        while(curA !=curB){//直到找相同的节点，返回
            curA = curA ==null ? headB : curA.next; //如果A先遍历完，就继续遍历B
            curB = curB == null ? headA : curB.next;//如果B遍历完后，继续遍历A链表；
        }
        return curA;
    }
}

142. 环形链表 II

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

解析：判断是否有环，设置fast指针、slow指针；fast每次移动两个节点，slow每次移动一个节点。直到fast和slow相遇了，将该点设置为index1。找个起始点的位置是x==z的情况。从头节点设置为index2，然后index1和index2开始移动，直到相遇。才是为相交的点。

public class Solution {
      public ListNode detectCycle(ListNode head) {

        ListNode fast=head;//fast指向头节点；
        ListNode slow=head;
        while ( fast !=null && fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
            
            if (slow == fast){
                //找到相遇的结点：
                ListNode index1=fast;
                ListNode index2=head;
                while(index1 !=index2){//不相遇的话就一直遍历；
                    index1=index1.next;
                    index2=index2.next;
                }
                return index1;//返回相遇节点，index1；
            }
        }
        return null;//如果没有的话就返回null；
    }
}