Day04 链表part02| LeetCode 24. 两两交换链表中的节点，19. 删除链表的倒数第 N 个，160. 相交链表，142. 环形链表 II

两两交换链表中的节点

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

 class Solution {
        public ListNode swapPairs(ListNode head) {
            //设置虚拟头节点
            ListNode dummy=new ListNode(0,head);

            ListNode cur=dummy;
            while(cur.next!=null&&cur.next.next!=null)
            {
                       ListNode tmp1=cur.next;
                       ListNode tmp2=cur.next.next;

                       tmp1.next=tmp2.next;
                       cur.next=tmp2;
                       tmp2.next=tmp1;

                       cur=cur.next.next;


            }
            return dummy.next;



        }
    }

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

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

• 双指针
  • 快指针比慢指针多走n步

 class Solution {
        public ListNode removeNthFromEnd(ListNode head, int n) {
            // 虚拟头节点
            ListNode dummy=new ListNode(0,head);

            //快、慢指针
            ListNode fast=dummy;
            ListNode slow=dummy;


            // 快指针比慢指针快n+1步，确保快慢指针相差n
         for(int i=0;i<n+1;i++)
         {
             fast=fast.next;
         }

            while(fast!=null)
            {
                slow=slow.next;
                fast=fast.next;
            }
            // fast.next==null,fast已经到了最后一个节点
            //slow节点此时为 要删除节点的 前一个节点

            //删除操作

//            if(slow.next!=null)
//            {
                slow.next=slow.next.next;

//            }
            return dummy.next;


        }
    }

链表相交

160. 相交链表

• 求两个链表交点节点的指针，而不是数值相等的指针

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
           int sizeMax=0,sizeMin=0;
           ListNode tmpMax=headA;
           ListNode tmpMin=headB;
           while(tmpMax!=null)
           {
               sizeMax++;
               tmpMax=tmpMax.next;


           }
            while(tmpMin!=null)
            {
                sizeMin++;
                tmpMin=tmpMin.next;

            }
            tmpMax=headA;
            tmpMin=headB;
            if(sizeMax<sizeMin)
            {
                //确保tmpMax 为最长链表的头，SizeMax为其长度
                int temp=sizeMin;
                sizeMin=sizeMax;
                sizeMax=temp;

              ListNode tmpNode=tmpMin;

                tmpMin=tmpMax;
                tmpMax=tmpNode;

            }
           int gap=sizeMax-sizeMin;


            while(gap>0)//末尾位置对齐
            {
                gap--;
                tmpMax=tmpMax.next;
                
            }

            while(tmpMax!=null&&tmpMin!=null)
            {
                if(tmpMax==tmpMin)
                {
                    return tmpMax;
                }
                tmpMax=tmpMax.next;
                tmpMin=tmpMin.next;
            }
            return null;
    }
}

环形链表

142. 环形链表 II

• 判断链表是否有环——双指针法

  • fast指针每次移动两个字节，slow指针每次移动一个字节
  • 如果存在环，则fast和slow指针必在环内相遇，且fast指针一定先进入环

• 如何找到环的入口
  

  public class Solution {
        public ListNode detectCycle(ListNode head) {
        ListNode fast=head;
        ListNode slow=head;
        while(fast!=null&&fast.next!=null)
        {
            slow=slow.next;
            fast=fast.next.next;

            if(slow==fast)//指针相遇
            {
                ListNode index1=fast;
                ListNode index2=head;
                while(index1!=index2)
                {
                    index1=index1.next;
                    index2=index2.next;
                }
                return index2;
                //环形入口

            }
        }
        return null;
        }
    }