【基础算法】链表篇

什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。

链表的入口节点称为链表的头结点也就是head。

移除链表元素

要求：删除链表中等于给定值的所有节点；直接使用原来的链表进行移除

方法：删除节点就是使节点的 next 指针指向需要移除的该节点的下一个节点就可以了，就是跳过需要移除的节点

注意：移除头节点和移除其他节点的操作是不一样的，因为链表中的其他节点是通过前一个节点来移除当前节点的，而头节点没有前一个节点（头节点后移就移除了链表中的一个头节点），所以在写代码的时候需要单独写一段逻辑在处理移除头节点

//链表数据结构
public static class ListNode {
  int val;
  ListNode next;
  ListNode() {}
  ListNode(int val) { this.val = val; }
  ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  @Override
  public String toString() {
    return "ListNode{" +
      "val=" + val +
      ", next=" + next +
      '}';
  }
}
//移除链表元素
public static ListNode removeElements(ListNode head, int val) {
        if (head == null){
            return head;
        }
        while(head != null && head.val == val){
          //移除头节点，头节点指向下一个节点
            head = head.next;
        }
        ListNode per = head;
        ListNode cur = head.next;
  			//如果当前节点不等于null，就循环执行判断值
        while (cur != null){
            if (cur.val == val){
              //当前节点值与目标值相同则移除当前节点
                per.next = cur.next;
            }else{
              //当前节点值与目标值不相同则移动指针到当前节点
                per = cur;
            }
          //无论当前值是否与目标值相同，一次循环之后都移动指针
            cur = cur.next;
        }
        return head;
}

设计链表

要求：在链表类中实现以下这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

public static class MyLinkedList {
  int size;
  //虚拟头节点
  ListNode head;
  //初始化链表
  public MyLinkedList(){
    size = 0;
    head = new ListNode(-100);//虚拟头节点
  }

  public int get(int index) {
    if (index < 0 || index > size){
      return -1;
    }
    ListNode cur = head;
    for (int i = 0; i < index + 1; i++){
      cur = cur.next;
    }
    return cur.val;
  }

  public void addAtHead(int val) {
    addAtIndex(0,val);
  }

  public void addAtTail(int val) {
    addAtIndex(size,val);
  }

  public void addAtIndex(int index, int val) {
    ListNode cur = head;
		// if (index < 0){ //等于在头节点前插入
    //     ListNode listNode = new ListNode(val);
    //     listNode.next = cur.next;
    //     cur.next = listNode;
    //     size++;
    //     return;
    // }
    // if(index > size){//等于在尾节点后插入
    //     ListNode cur = head;
    //     ListNode listNode = new ListNode(val);
    //     for(int i = 0; i < size; i++){
    //         cur = cur.next;
    //     }
    //     listNode.next = null; //(listNode.next = cur.next;)
    //     cur.next = listNode;
    //     size++;
    //     return;
    // }
    //在除头节点和尾节点之外的位置插入
    //插入位置非法，1.索引位置小于0，在链表头节点插入新节点，不会进入for循环，执行下面的通用代码块
    //插入位置非法，2.索引位置大于size，在尾节点后插入新节点，链表遍历到null就跳出循环，
    for (int i = 0; i < index; i++){
      cur = cur.next;
      if (cur.next == null){
        break;
      }
    }
    //三种情况的通用代码
    ListNode listNode = new ListNode(val);
    listNode.next = cur.next;
    cur.next = listNode;
    size++;
  }
  
  public void deleteAtIndex(int index) {
    //按照题目要求，如果索引index有效，则删除第index个节点，实际删除的是索引为index-1的节点
    //如果索引无效，我们就不操作吧
    if (index < 0 || index >= size){
      return;
    }
    ListNode cur = head;
    for (int i = 0; i < index-1; i++){
      cur = cur.next;
    }
    cur.next = cur.next.next;
    size--;
  }
}

反转链表

要求：不能重新new一个链表，增大了空间开销，我们应该在原链表上操作

关键：改变原链表的next指针的方向，反转链表

方法：双指针移动

 public static ListNode reverseList(ListNode head) {
        ListNode pre =null;//新指针
        ListNode cur = head;//旧指针，遍历原链表直到为null
        ListNode next = null;//存储旧指针指向的下一个节点
        while(cur != null){
            next = cur.next;//这一步很关键，cur.next=pre时，原链表的指针就断掉了没有办法到下一个节点了，要提前保留下一个节点
            cur.next = pre; //这一步的赋值操作就是将节点的指针反转
            pre = cur;
            cur = next; //这里看似cur = cur.next; 但是要注意，在next赋值的下一句，将cur.next的值已经改变了
        }
        return pre;
    }

两两交换链表元素

难点：真的没搞懂那个指针的变化

关键：主要是head.next.next = head 这句把我整懵了，不是很理解，有新的理解再来

public static ListNode swapPairs(ListNode head) {
        ListNode virtualNode = new ListNode(-1);//虚拟头节点
        virtualNode.next = head;
        ListNode cur = virtualNode;//活动指针
        while(cur.next != null && cur.next.next != null){
            ListNode temp = head.next.next;//缓存原链表的第三个节点
            //改变链接
            cur.next = head.next;//虚拟头节点next指向原链表的head的next
            head.next.next = head;//原链表的head的next那个节点的next指向原链表的head，原链表的第一个链就改变了
            head.next = temp;//原链表的head的next就指向原链表的第三个节点了
            //移动指针位置
            cur = head;
            head = head.next;
        }
        return virtualNode.next;
    }

删除链表倒数第N个节点

要求：只遍历一次链表

关键：找到突破口，要想到先移动N个节点再同时移动两个指针，先移动N个节点的指针为null的时候，后移动的指针就是我们要删除的节点。

方法：双指针，一个先移动N个节点，然后两个指针同时移动，当快指针为空的时候，慢指针对应的节点就是我们要删除的节点，fast - solw = N

public static ListNode removeNthFromEnd(ListNode head, int n) {
  ListNode fast = head, slow = head;
  //先将快指针移动N个节点
  for (int i = 0; i < n; i++){
    fast = fast.next;
  }
  //如果此时fast为空，说明倒数第n个节点就是链表的头节点，删除头节点返回结束
  if (fast == null){
    head = head.next;
    return head;
  }
  //需要记住待删除节点的上一个节点，便于删除
  ListNode slowPre = null;
  //当快指针还没有指向NULL之前，同步移动快慢指针
  while(fast != null){
    slowPre = slow;
    fast = fast.next;
    slow = slow.next;
  }
  slowPre.next = slow.next;
  //释放删除的节点
  slow.next = null;
  return head;
}

链表相交

第一次：题的要求我都没懂，看了代码还是不晓得它在干啥

第二次：求两个链表交点节点的指针。 交点不是数值相等，而是指针相等？？？

利用哈希集合思路和算法（力扣官方），这个就很好理解了

判断两个链表是否相交，可以使用哈希集合存储链表节点。

首先遍历链表 headA，并将链表 headA 中的每个节点加入哈希集合中。然后遍历链表 headB，对于遍历到的每个节点，判断该节点是否在哈希集合中：

• 如果当前节点不在哈希集合中，则继续遍历下一个节点；

• 如果当前节点在哈希集合中，则后面的节点都在哈希集合中，即从当前节点开始的所有节点都在两个链表的相交部分，因此在链表 headB 中遍历到的第一个在哈希集合中的节点就是两个链表相交的节点，返回该节点。

如果链表 headB 中的所有节点都不在哈希集合中，则两个链表不相交，返回 null。

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
  Set<ListNode> visited = new HashSet<ListNode>();
  ListNode temp = headA;
  while (temp != null) {
    visited.add(temp);
    temp = temp.next;
  }
  temp = headB;
  while (temp != null) {
    if (visited.contains(temp)) {
      return temp;
    }
    temp = temp.next;
  }
  return null;
}

环形链表

前提：不能改变原链表的结构

要求：如果链表中没有环就返回-1，否则返回链表入环的位置

难点：首先怎么判断链表有没有环呢？怎么确定入环的那个节点呢

方法：使用快慢指针，快指针一次移动两个节点，慢指针一次移动一个节点，如果两个指针在途中相遇了，说明这个链表存在环，这里为什么说快指针一次移动两个节点，慢指针一次移动一个指针，它们两个一定会相遇呢？

首先第一点：fast指针一定先进入环中，如果fast指针和slow指针相遇的话，一定是在环中相遇，这是毋庸置疑的。

那么，为什么fast指针和slow指针一定会相遇呢？

画一个环，然后让 fast指针在任意一个节点开始追赶slow指针。因为fast是走两步，slow是走一步，其实相对于slow来说，fast是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合。

public static ListNode detectCycle(ListNode head) {
  ListNode fast = head;
  ListNode slow = head;
  while(fast != null && fast.next != null){
    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; 
}