Problema de ventana deslizante de doble puntero (implementación de Java del problema de Leetcode)

Leetcode141. Determine si hay un anillo en la lista vinculada

• Idea: establezca los punteros duales rápidos y lentos, el puntero lento +1 es el puntero rápido +2. Si no contiene un anillo, el puntero rápido eventualmente encontrará un valor nulo, lo que indica que la lista vinculada no contiene un anillo; si contiene un anillo, el puntero rápido eventualmente será un puntero súper lento y se encontrará con el puntero lento, lo que indica que la lista vinculada contiene un anillo. La complejidad del tiempo es O (n).

public class Solution {
    //如果环的长度为 M，经过 M 次迭代后，快指针肯定会多绕环一周，赶上慢指针。
    public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null) 
           return false;
        ListNode slow = head;
        ListNode fast = head;
        while (fast == null || fast.next == null) {
            //如果没有环，快指针将停在链表的末尾。快指针每次走两步
            slow = slow.next;
            fast = fast.next.next;
            if (fast == slow) {  return true; }
        }
        return false;
    }
}

Leetcode142. Determine la entrada del anillo de la lista vinculada

• Idea: puntero doble, lo mismo que el simple problema de la lista de timbres
  Cuando el primer puntero y el puntero rápido (1) se encuentran, hay rápido = lento + k longitud del anillo y rápido = 2 lento para obtener lento = k longitud del anillo. Nota: Suponiendo que un puntero puede ir un paso desde el encabezado de la lista enlazada al nodo de entrada del anillo, entonces el número de pasos desde el encabezado de la lista enlazada hasta la entrada del anillo es una longitud del anillo + k , por lo que se puede alcanzar un paso lento después de la primera intersección
  Después de que los dos primeros punteros se encuentren en la entrada del anillo (2), deje que el nodo rápido apunte al encabezado de la lista vinculada. Luego, los punteros rápidos y lentos avanzan sincrónicamente, para asegurar que cuando el segundo encuentro, los punteros rápidos y lentos apunten a la entrada del anillo.

public ListNode detectCycle(ListNode head) {
          if(head==null) return null;
          ListNode slow = head;
          ListNode fast = head;
          while (fast != null && fast.next != null) {
              fast = fast.next.next;
              slow = slow.next;
              if (fast == slow) break;
          }
          fast = head;  //快指针指回头结点
          while(slow!=fast){  //第二次相交前快慢指针都一步步走
              fast = fast.next;
              slow = slow.next;
          }
          return slow;
    }

Leetcode443. Cadena comprimida

class Solution {
    public int compress(char[] chars) {
        public int compress(char[] chars) {
        if(chars.length == 0) return 0;
        int p=0; int left=0,right =1; // p指针指向最新修改的数组位，还有两个窗口的左右指针
        while(left<chars.length){
            chars[p++] = chars[left];//p位存下左字符后+1
            while(right<chars.length && chars[left]==chars[right]){
                right++;  //相同时溢出
            }
            if(right-left >1){
                String temp = String.valueOf(right-left);
                for(char ch:temp.toCharArray()){
                    chars[p++] = ch;
                }
            }
            left = right;
        }
        return p;
    }
}