Exercícios - o primeiro nó comum de duas listas vinculadas

O primeiro nó comum das duas listas vinculadas

1. Descrição do título

• Entre nas duas listas vinculadas e encontre seu primeiro nó comum.

2. Descrição de entrada e saída

• Conforme mostrado na figura abaixo, o nó público é o nó 8
  

3. Implementação do código

• O primeiro método , usando a não repetibilidade de HashSet

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    
    
    //第一种：用HashSet
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    
    
        //可以选择set将A全部放进去，然后遍历B，如果有直接返回节点，最后返回null；
        Set<ListNode> set = new HashSet<>();
        while(headA != null){
    
    
            set.add(headA);
            headA = headA.next;
        }

        while(headB != null){
    
    
            if(set.contains(headB)){
    
    
                return headB;
            }
            headB = headB.next;
        }
        return null;
}
}

• O segundo método ; travessia, se o comprimento das duas listas vinculadas não for o mesmo, deixe aquela com o mesmo comprimento ir primeiro, espere que eles tenham o mesmo comprimento, vão juntos, e então o mesmo nó é o resultado
  

在这里插入代码片/**
 * 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) {
    
    
        //2.让链表长度长的先走，直到他们俩个长度一致，然后一起走，直达找到一样的返回，否则就返回null；
       int lenA = length(headA); int lenB = length(headB);
        while(lenA != lenB){
    
    
            if(lenA > lenB){
    
    
                headA = headA.next;
                lenA--;
            }else{
    
    
                headB = headB.next;
                lenB--;
            }
        }
        //到了这里俩者长度一致，一起走
        while(headA != null){
    
    
            if(headA == headB){
    
    
                return headA;
            }
            headA = headA.next;
            headB = headB.next;

        }
        return null;
    }
    //统计链表的长度
private int length(ListNode node) {
    
    
    int length = 0;
    while (node != null) {
    
    
        node = node.next;
        length++;
    }
    return length;
}
}

• O terceiro método

1. As duas listas vinculadas começam a percorrer ao mesmo tempo. Se a lista vinculada A estiver concluída, inicie a travessia a partir do nó principal de B;
2. Da mesma forma, quando B terminar, atravesse o nó principal de A;
3. Até que os dois nós atravessados ​​coincidam, o resultado é;
   
   

在这里插入代码片/**
 * 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) {
    
    
    //第三种
    //tempA和tempB我们可以认为是A,B两个指针
    ListNode tempA = headA;
    ListNode tempB = headB;
    while (tempA != tempB) {
    
    
        //如果指针tempA不为空，tempA就往后移一步。
        //如果指针tempA为空，就让指针tempA指向headB（注意这里是headB不是tempB）
        tempA = tempA == null ? headB : tempA.next;
        //指针tempB同上
        tempB = tempB == null ? headA : tempB.next;
    }
    //tempA要么是空，要么是两链表的交点
    return tempA;
}
}