代码随想录第四天||24. 两两交换链表中的节点、 19.删除链表的倒数第N个节点、面试题 02.07. 链表相交 、 142.环形链表II

24交换链表中的节点

 题目链接：

24. 两两交换链表中的节点

//递归      
  if(head==null||head.next==null){
            return head;}

        ListNode cur=head;
        ListNode curN=head.next;
        ListNode curNN=curN.next;
        ListNode temp=new ListNode();
        temp.next=curN;
        curN.next=cur;
        cur.next=swapPairs(curNN);
        return curN;

//第二种方法
if(head==null||head.next==null){return head;}

        ListNode cur;
        ListNode curPre;
        ListNode curNext;
        ListNode h=new ListNode();
        
        cur=head;
        curNext=cur;
        curPre=h;
        ListNode t;
        while(cur!=null&&cur.next!=null){
                
                curNext=cur.next;
                t=curNext.next;
                curPre.next=curNext;
                curNext.next=cur;
                cur.next=t;
                curPre=cur;
                cur=t;

        }return h.next;

---

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

题目链接：

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

• 看到这个题，第一反应就是遍历链表，先把链表的长度算出来，再遍历一遍，把倒数第n+1个元素找到，然后进行删除

        //遍历
        ListNode h=new ListNode();
        h.next=head;
        ListNode cur=h;
        int i=0;//有i个元素
        while(cur!=null){
            cur=cur.next;
            i++;
        }
        //找倒数第i+1个
        cur=h;
        int j=0;
        while(j<i-n-1){
            cur=cur.next;
            j++;
        }
        cur.next=cur.next.next;
        return h.next;

• 看了下题解，发现可以用双指针做！

• 
  
          int fast_index=0;
          int slow_index=0;
  
          ListNode h=new ListNode();
          h.next=head;//虚拟头节点，方便后面删除第一个元素
          ListNode fast=h;
          ListNode slow=h;
          while(fast_index-slow_index<n){
          //因为是删除链表，所以要找的应该是倒数第n+1个节点。
              fast_index++;
              fast=fast.next;
          }
  
          while(fast.next!=null){
              fast=fast.next;
              slow=slow.next;
          }
  
  
          slow.next=slow.next.next;
          return h.next;
  

  感觉双指针就是用来代替循环的，如果某个算法涉及到多次/多重循环并且有很明确的边界条件，就可以考虑一下用双指针的方法。

---

 面试题 02.07. 链表相交

题目链接：

面试题 02.07. 链表相交

一、代码

• 第一反应就是用两个for循环去遍历两个链表，比较每个元素是否相等。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode p1=headA;
        ListNode p2=headB;
        while(p1!=null){
            p2=headB;
            while(p2!=null){
                if(p1.equals(p2)){
                    return p1;
                }else{
                    p2=p2.next;
                }
            }
            p1=p1.next;
        }
        return null;

    }
}

显然这种方法是很不好的。。。。。

• 看了眼题解，用了很简单的方法，但是我想不到QAQ
• 用题解的方法做的时候犯了个错：
• 错误写法：

        ListNode p1=headA;
        ListNode p2=headB;
            while(p1!=p2){
                if(p1.next==null){//这里应该写p1==null
                    p1=headB;
                }else {p1=p1.next;}

                if(p2.next==null){//这里应该写p2==null，如果写成我这样，当A链表和B链表不相交的时候，是没办法退出while循环的
                    p2=headA;
            }else {
            p2=p2.next;}
    }return p1;

 改了之后：

        ListNode p1=headA;
        ListNode p2=headB;
            while(p1!=p2){
                if(p1==null){
                    p1=headB;
                }else {p1=p1.next;}

                if(p2==null){
                    p2=headA;
            }else {
            p2=p2.next;}
    }return p1;

---

 142.环形链表II  

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

1、代码：

看到这个题我只能想到怎么去判断里面有没有环，看了题解之后，才把后面的补齐。

看来有些算法题还是需要手动推算一下的。。。。

• 我写的时候，是把找第一次相遇的点和找交点分成两个循环写的：

        ListNode fast=head;
        ListNode slow=head;

        //先找到第一次相遇的点；
        while(fast!=null){
            fast=fast.next;
            if(fast!=null){
                fast=fast.next;
            }else{
                return fast;
            }
            if(fast==null)return fast;
            slow=slow.next;
            if(fast==slow){break;}
        }
        fast=head;
        //然后让其中一个指针从head开始遍历，最后相遇的地方就是交点；
        while(fast!=slow){
            fast=fast.next;
            slow=slow.next;
        }

        return fast;

• 看了别人写的，发现第一步和第二步完全可以合并到一个循环里面去实现。

  
          ListNode fast=head;
          ListNode slow=head;
          while(fast!=null){
                  fast=fast.next;
                  if(fast==null){return fast;}
                  fast=fast.next;
                  slow=slow.next;
                  if(slow==fast){
                          ListNode temp1=head;
                          while(temp1!=slow){
                              temp1=temp1.next;
                              slow=slow.next;
                          }
                          return temp1;
                  }
          }
          return null;