160. Intersection of Two Linked Lists

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        unordered_set<ListNode *> visited;
        ListNode *temp = headA;
        while (temp != nullptr) {
            visited.insert(temp);
            temp = temp->next;
        }
        temp = headB;
        while (temp != nullptr) {
            if (visited.count(temp)) {
                return temp;
            }
            temp = temp->next;
        }
        return nullptr;
    }
};

public class Solution {
    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;
    }
}

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getIntersectionNode(self, headA: 'ListNode', headB: 'ListNode') -> 'ListNode | None':
        a, b = headA, headB
        while a is not b:
            a = a.next if a else headB
            b = b.next if b else headA
        return a

var getIntersectionNode = function(headA, headB) {
    const visited = new Set();
    let temp = headA;
    while (temp !== null) {
        visited.add(temp);
        temp = temp.next;
    }
    temp = headB;
    while (temp !== null) {
        if (visited.has(temp)) {
            return temp;
        }
        temp = temp.next;
    }
    return null;
};

interface ListNode {
  val: number
  next: ListNode | null
}

function getIntersectionNode(headA: ListNode | null, headB: ListNode | null): ListNode | null {
  let a: ListNode | null = headA, b: ListNode | null = headB
  while (a !== b) {
    a = a ? a.next : headB
    b = b ? b.next : headA
  }
  return a
}

public class ListNode {
    public int val;
    public ListNode next;
    public ListNode(int x) { val = x; }
}

public class Solution {
    public ListNode GetIntersectionNode(ListNode headA, ListNode headB) {
        ListNode a = headA, b = headB;
        while (a != b) {
            a = (a != null) ? a.next : headB;
            b = (b != null) ? b.next : headA;
        }
        return a;
    }
}

struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode *a = headA, *b = headB;
    while (a != b) {
        a = a ? a->next : headB;
        b = b ? b->next : headA;
    }
    return a;
}

func getIntersectionNode(headA, headB *ListNode) *ListNode {
    vis := map[*ListNode]bool{}
    for tmp := headA; tmp != nil; tmp = tmp.Next {
        vis[tmp] = true
    }
    for tmp := headB; tmp != nil; tmp = tmp.Next {
        if vis[tmp] {
            return tmp
        }
    }
    return nil
}

class ListNode(var `val`: Int) { var next: ListNode? = null }

fun getIntersectionNode(headA: ListNode?, headB: ListNode?): ListNode? {
    var a = headA
    var b = headB
    while (a !== b) {
        a = if (a != null) a.next else headB
        b = if (b != null) b.next else headA
    }
    return a
}

public class ListNode {
    public var val: Int
    public var next: ListNode?
    public init(_ val: Int) { self.val = val; self.next = nil }
}

func getIntersectionNode(_ headA: ListNode?, _ headB: ListNode?) -> ListNode? {
    var a = headA, b = headB
    while a !== b {
        a = (a != nil) ? a!.next : headB
        b = (b != nil) ? b!.next : headA
    }
    return a
}

class ListNode
  attr_accessor :val, :next
  def initialize(val = 0, nxt = nil)
    @val = val
    @next = nxt
  end
end

def get_intersection_node(headA, headB)
  a = headA
  b = headB
  while a != b
    a = a ? a.next : headB
    b = b ? b.next : headA
  end
  a
end

<?php
class ListNode {
    public $val;
    public $next;
    function __construct($val = 0, $next = null) { $this->val = $val; $this->next = $next; }
}

function getIntersectionNode($headA, $headB) {
    $a = $headA; $b = $headB;
    while ($a !== $b) {
        $a = $a ? $a->next : $headB;
        $b = $b ? $b->next : $headA;
    }
    return $a;
}

class ListNode(var x: Int = 0, var next: ListNode = null)

object Solution {
  def getIntersectionNode(headA: ListNode, headB: ListNode): ListNode = {
    var a: ListNode = headA
    var b: ListNode = headB
    while (a ne b) {
      a = if (a != null) a.next else headB
      b = if (b != null) b.next else headA
    }
    a
  }
}