算法第四天，链表2

type ListNode struct {

  Val  int

  Next *ListNode

}

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

func swapPairs(head *ListNode) *ListNode {

  dummyHead := &ListNode{}

  dummyHead.Next = head

  cur := dummyHead

  for cur.Next != nil && cur.Next.Next != nil {

     //保存第一个节点

    temp := cur.Next

    //保存第三个节点

    temp2 := cur.Next.Next.Next

   //让第一个节点指向第二个节点

    cur.Next = cur.Next.Next

    //让第二个节点指向第一个节点， 完成交换

    cur.Next.Next = temp

    //最后让原第一个节点指向第三个节点

    temp.Next = temp2

   //指针向后移动两步

    cur = cur.Next.Next

  }

  return dummyHead.Next

}

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

func removeNthFromEnd(head *ListNode, n int) *ListNode {

  dummyHead := &ListNode{}

  dummyHead.Next = head

 //设置快慢指针

  cur := dummyHead

  slow := dummyHead

 //先让快指针移动n位

  for i := 0; i < n && cur != nil; i++ {

    cur = cur.Next

  }

  // 快指针在移动1步，总体移动n+1

  cur = cur.Next

  //快慢指针同时移动，直到快指针到链表结尾，找到要删除节点的前一个节点

  for cur != nil {

    cur = cur.Next

    slow = slow.Next

  }

 //删除目标节点

  slow.Next = slow.Next.Next

  return dummyHead.Next

}

142. 环形链表 II

func detectCycle(head *ListNode) *ListNode {

 //设置快慢指针，指向头结点

  cur := head

  slow := head

  for cur != nil && cur.Next != nil {

     //慢指针移动1步

    slow = slow.Next

   // 快指针移动2步

    cur = cur.Next.Next

   //如果相等说明有环

    if cur == slow {

      index := slow

      index2 := head

     //移动慢指针和头指针，直到找到相同点

      for index != index2 {

        index = index.Next

        index2 = index2.Next

      }

      //找到相同点返回

      return index

    }

  }

  //如果快慢指针不相等说明没有环，返回空值

  return nil

}

面试题 02.07. 链表相交

func getIntersectionNode(headA, headB *ListNode) *ListNode {

  curA := headA

  curB := headB

  lenA := 0

  lenB := 0

  // 计算headA长度

  for curA != nil {

    curA = curA.Next

    lenA++

  }

  // 计算headB长度

  for curB != nil {

    curB = curB.Next

    lenB++

  }

 //让curA为最长链表

  if lenB > lenA {

    curA = headB

    curB = headA

    temp2 := lenA

    lenA = lenB

    lenB = temp2

  } else {

    curA = headA

    curB = headB

  }

  //计算链表A和链表B长度之差

  gap := lenA - lenB

   //让最长链表curA移动到和curB长度相等

  for gap > 0 {

    curA = curA.Next

    gap--

  }

   //让curA和curB同时移动，判断有相同值，如果有说明链表相交，然后返回相交点

  for curA != nil {

    if curA == curB {

      return curA

    }

    curA = curA.Next

    curB = curB.Next

  }

 //不相等说明没有相交，返回为空

  return nil

}