算法学习|Day4链表收尾|Leetcode 24.两两交换链表节点 19.删除链表的倒数第N个节点 142.环形链表 II M

链表 part02

1. 24 两两交换链表节点 M

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

1. 1使用虚拟头节点

1.1.1 思路分析

  • 代码终止条件是什么?

    如上图,第一次交换完后,cur指向1的时候,接下来3与4交换,此后cur指向交换后的3,这时候只剩下5不能交换。

    奇数:cur .next .next=null

    偶数:cur.next=null 或者空节点的话也是这么个条件

  • 每一次交换完后,cur指向下一次交换的前一个节点

  • 两个交换节点需要提前保存第一个,以及这两节点之后的另一个节点

1.1.2. 解法
class Solution {
  public ListNode swapPairs(ListNode head) {
        ListNode dumyhead = new ListNode(-1); // 设置一个虚拟头结点
        dumyhead.next = head; // 将虚拟头结点指向head,这样方面后面做删除操作
        ListNode cur = dumyhead;
        ListNode temp; // 临时节点,保存两个节点后面的节点
        ListNode firstnode; // 临时节点,保存两个节点之中的第一个节点
        ListNode secondnode; // 临时节点,保存两个节点之中的第二个节点
        while (cur.next != null && cur.next.next != null) {
            temp = cur.next.next.next;
            firstnode = cur.next;
            secondnode = cur.next.next;
            cur.next = secondnode;       // 步骤一
            secondnode.next = firstnode; // 步骤二
            firstnode.next = temp;      // 步骤三
            cur = firstnode; // cur移动,准备下一轮交换
        }
        return dumyhead.next;  
    }
}

1.2 递归

1.2.1 思路分析

使用递归来解决该题,主要就是递归的三部曲

  1. 找终止条件:本题终止条件很明显,当递归到链表为空或者链表只剩一个元素的时候,没得交换了,自然就终止了。
  2. 找返回值:返回给上一层递归的值应该是已经交换完成后的子链表
  3. 单次的过程:设需要交换的两个点为 headnexthead 连接后面交换完成的子链表,next 连接 head,完成交换

解决递归问题

1.2.2 解法
class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null ||head.next == null) {
            return head;
        }
        ListNode next = head.next;
        //递归
        ListNode newNode = swapPairs(next.next);//子链表返回新的头节点newNode
        //交换
        next.next = head;
        head.next = newNode;
        //返回新的链表的头节点
        return next;
    }
}
  • 时间复杂度:O(n),其中 n 是链表的节点数量。需要对每个节点进行更新指针的操作。
  • 空间复杂度:O(n),其中 n 是链表的节点数量。空间复杂度主要取决于递归调用的栈空间。

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

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

2.1 思路分析

  • 设置一个虚拟头节点,使得删除第一个和其他节点操作一样
  • 采用快慢指针
    • 让快指针先往前移动,只要快慢指针相差n个节点
    • 因为加了一个虚拟头节点,所以先让快指针移n+1个节点,之后快慢指针同时移动,直到快指针移动到空,此时slow指向要删节点的前驱

2.2 双指针解法

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //创建一个虚拟头节点,并指向头节点
        ListNode dummyNode=new ListNode(0,head);

        //创建快慢指针
        ListNode fast=dummyNode;
        ListNode slow=dummyNode;

        //因为有虚拟头结点了,所以移动n+1个节点
        for (int i = 0; i < n+1; i++) {
            fast=fast.next;
        }
      /*  //在移动一个节点
        fast=fast.next;*/
       //快慢指针同时移动
        while (fast!=null){
            fast=fast.next;
            slow=slow.next;
        }
        slow.next=slow.next.next;
        return dummyNode.next;
    }
}

3. 160 相交链表

给你两个单链表的头节点 headAheadB ,请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点,返回 null

3.1 思路分析

  • 先求出A B两链表长度差,然后让长链表移动到与锻炼表平齐,长短两表一起移动,直到curA=curB;

3.2 解题代码

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        //A B长度
        int lenA = 0, lenB = 0;
        //求A长度
        while (curA != null) {
            lenA++;
            curA = curA.next;
        }
        //B长度
        while (curB != null) {
            lenB++;
            curB = curB.next;
        }
        //当前两节点指向A B
        curA = headA;
        curB = headB;
		//统一A长度大于B
        if (lenB > lenA) {
            int tmpLen = lenA;
            lenA = lenB;
            lenB = tmpLen;

            ListNode tmpNode = curA;
            curA = curB;
            curB = tmpNode;
        }

        //求长度差
        int gap = lenA - lenB;
        //让curA和curB在同一起点(末尾位置对齐)
        while (gap != 0) {
            curA = curA.next;
            gap--;
        }

        //遍历curA和curB,遇到相同则直接返回
        while (curA != null) {
            if (curA == curB) {
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }
}
  • 时间复杂度:O(n + m)
  • 空间复杂度:O(1)

3.3另一种方法——双指针(思路绝了!!)

3.3.1 思路分析

这个真的没想到,啥也不说了,看力扣解答吧:链接,这不是我等凡人能想出来的,呜呜呜…

3.3.2 解题代码
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        /*
        A走完回B出发点,B走完回A出发点,根据走过的节点数一致即可判断的
        相交的在相交节点处相遇,否则在null相遇
         */

        ListNode A = headA, B = headB;
        while (A != B) {
            //判断A或B是否为空,然后取后面问号的值,并赋给A,B
            // 细节:需要将空节点包含进路径中
            A = A != null ? A.next : headB;
            B = B != null ? B.next : headA;
        }
        return A;
    }
}
  • 时间复杂度 O(a+b): 最差情况下(即 ∣a−b∣=1|a - b| = 1∣a−b∣=1 , c=0c = 0c=0 ),此时需遍历 a+ba + ba+b 个节点。
  • 空间复杂度 O(1): 节点指针 A , B 使用常数大小的额外空间。

4. 142 环形链表 II M

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

4.1 思路分析

  1. 判断链表是否有环?

    快慢指针法,分别定义fast和slow指针,从头结点出发,fast指针每次移动两个结点,slow指针每次移动一个结点,如果途中相遇,说明该链表有环。

  2. 如果有环,如何找到环入口?

    头结点发出一个指针,从相遇结点发出一个指针,这两个指针每次只走一个结点,那么当这两个指针相遇的时候就是环形入口的结点。

4.2 双指针解法

public class Solution {
    public ListNode detectCycle(ListNode head) {
        //设置快慢指针
        ListNode slow=head;
        ListNode fast=head;
        //快慢指针开始移动,快指针每次移动两节点,慢指针每次移动1节点
        while (fast != null && fast.next != null) {//为什么也要判断 fast.next != null?因为快指针每次移动2步,所以要判断它下一个是否为空
            fast=fast.next.next;
            slow=slow.next;
            //快慢指针相遇了
            if (fast==slow) {//相等说明有环啦~
                ListNode index1=fast;//相遇节点     因为这时候快慢指针是一块了
                ListNode index2=head;//头结点
                //两个指针,从头结点和相遇结点,各走一步,直到相遇,即为环入口(此处证明网上有说明)
                while (index1 != index2) {
                    index1=index1.next;
                    index2=index2.next;
                }
                //返回入环第一个节点
                return index1;
            }
        }
        return null;
    }
}
  • 时间复杂度:O(N)

    • 快慢指针相遇前,指针走的次数小于链表长度,快慢指针相遇后,两个index指针走的次数也小于链表长度,总体为走的次数小于 2n
  • 空间复杂度:O(1)

    • 只使用了 slow,fast,index1,index2 四个指针。

你可能感兴趣的:(算法笔记,链表,算法,leetcode)