Merge branch 'DaleStudy:main' into main

Author: KwonNayeon

clone-graph/YoungSeok-Choi.java

@@ -0,0 +1,86 @@
+import java.util.HashMap;
+import java.util.Map;
+
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> neighbors;
+    public Node() {
+        val = 0;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val) {
+        val = _val;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val, ArrayList<Node> _neighbors) {
+        val = _val;
+        neighbors = _neighbors;
+    }
+}
+*/
+class Solution {
+    public Map<Node, Node> nMap = new HashMap<>();
+
+    public Node cloneGraph(Node node) {
+        if (node == null)
+            return null;
+
+        if (nMap.containsKey(node)) {
+            return nMap.get(node);
+        }
+
+        Node clone = new Node(node.val);
+        nMap.put(node, clone);
+
+        for (Node nei : node.neighbors) {
+            clone.neighbors.add(cloneGraph(nei));
+        }
+
+        return clone;
+    }
+}
+
+class WrongSolution {
+    public Node graph;
+    public Map<Node, Node> nMap = new HashMap<>();
+
+    public Node cloneGraph(Node node) {
+        if (node == null)
+            return null;
+
+        graph = new Node(node.val);
+        nMap.put(node, graph);
+
+        // print(graph);
+
+        return clone(node, graph);
+    }
+
+    public Node clone(Node node, Node cur) {
+        for (int i = 0; i < node.neighbors.size(); i++) {
+            Node adj = node.neighbors.get(i);
+
+            if (nMap.containsKey(adj)) {
+                return nMap.get(adj);
+            }
+
+            nMap.put(adj, new Node(adj.val));
+            cur.neighbors.add(nMap.get(adj));
+            clone(adj, nMap.get(adj));
+        }
+
+        return cur;
+    }
+
+    public void print(Node node) {
+        System.out.println("visit " + node.val);
+
+        for (int i = 0; i < node.neighbors.size(); i++) {
+            Node adj = node.neighbors.get(i);
+            System.out.println("nei " + adj.val);
+            print(adj);
+        }
+    }
+}

clone-graph/byol-han.js

@@ -0,0 +1,37 @@
+/**
+ * https://leetcode.com/problems/clone-graph/
+ * // Definition for a _Node.
+ * function _Node(val, neighbors) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.neighbors = neighbors === undefined ? [] : neighbors;
+ * };
+ * 시간 복잡도: O(N) — 노드 수만큼 순회
+ * 공간 복잡도: O(N) — visited 맵과 재귀 호출 스택
+ */
+
+/**
+ * @param {_Node} node
+ * @return {_Node}
+ */
+var cloneGraph = function (node) {
+  if (!node) return null;
+
+  const visited = new Map();
+
+  const dfs = (n) => {
+    if (visited.has(n)) {
+      return visited.get(n);
+    }
+
+    const clone = new Node(n.val);
+    visited.set(n, clone);
+
+    for (let neighbor of n.neighbors) {
+      clone.neighbors.push(dfs(neighbor));
+    }
+
+    return clone;
+  };
+
+  return dfs(node);
+};

clone-graph/krokerdile.js

@@ -0,0 +1,27 @@
+/**
+ * @param {_Node} node
+ * @return {_Node}
+ */
+var cloneGraph = function(node) {
+    if (!node) return null;
+
+    const visited = new Map(); // 원본 노드 -> 복제 노드
+
+    function dfs(curr) {
+        if (visited.has(curr)) {
+            return visited.get(curr); // 이미 복제한 경우
+        }
+
+        const copy = new _Node(curr.val);
+        visited.set(curr, copy); // 복제한 노드 저장
+
+        for (const neighbor of curr.neighbors) {
+            copy.neighbors.push(dfs(neighbor)); // 이웃도 재귀적으로 복사
+        }
+
+        return copy;
+    }
+
+    return dfs(node);
+};
+

linked-list-cycle/HoonDongKang.ts

@@ -0,0 +1,44 @@
+/**
+ * [Problem]: [141] Linked List Cycle
+ * (https://leetcode.com/problems/linked-list-cycle/description/)
+ */
+class ListNode {
+    val: number;
+    next: ListNode | null;
+    constructor(val?: number, next?: ListNode | null) {
+        this.val = val === undefined ? 0 : val;
+        this.next = next === undefined ? null : next;
+    }
+}
+
+function hasCycle(head: ListNode | null): boolean {
+    //시간복잡도 O(n)
+    //공간복잡도 O(n)
+    function setFunc(head: ListNode | null): boolean {
+        if (!head) return false;
+        const set = new Set<ListNode>();
+        let currentNode: ListNode = head;
+
+        while (currentNode) {
+            if (set.has(currentNode)) return true;
+
+            set.add(currentNode);
+            currentNode = currentNode.next!;
+        }
+
+        return false;
+    }
+    //시간복잡도 O(n)
+    //공간복잡도 O(1)
+    function pointerFunc(head: ListNode | null): boolean {
+        let slow = head;
+        let fast = head;
+        while (fast && fast.next) {
+            slow = slow.next;
+            fast = fast.next.next;
+
+            if (slow === fast) return true;
+        }
+        return false;
+    }
+}

linked-list-cycle/Jeehay28.ts

@@ -0,0 +1,52 @@
+class ListNode {
+  val: number;
+  next: ListNode | null;
+  constructor(val?: number, next?: ListNode | null) {
+    this.val = val === undefined ? 0 : val;
+    this.next = next === undefined ? null : next;
+  }
+}
+
+// TC: O(n)
+// SC: O(1)
+function hasCycle(head: ListNode | null): boolean {
+
+  let fast: ListNode | null = head;
+  let slow: ListNode | null = head;
+
+  while (fast && fast.next) {
+    fast = fast.next.next;
+
+    if (slow !== null) {
+      slow = slow.next;
+    } else {
+      return false;
+    }
+
+    if (fast === slow) return true;
+  }
+
+  return false;
+}
+
+
+// TC: O(n)
+// SC: O(n)
+/*
+function hasCycle(head: ListNode | null): boolean {
+
+  let dummy: ListNode | null = head;
+  const visited = new Set<ListNode>();
+
+  while (dummy) {
+    if (visited.has(dummy)) return true;
+
+    visited.add(dummy);
+
+    dummy = dummy.next;
+  }
+
+  return false;
+}
+*/
+

linked-list-cycle/PDKhan.cpp

@@ -0,0 +1,17 @@
+class Solution {
+    public:
+        bool hasCycle(ListNode *head) {
+            ListNode* slow = head;
+            ListNode* fast = head;
+    
+            while(fast && fast->next){            
+                slow = slow->next;
+                fast = fast->next->next;
+    
+                if(slow == fast)
+                    return true;
+            }
+    
+            return false;
+        }
+    };

linked-list-cycle/Tessa1217.java

@@ -0,0 +1,57 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+/**
+ * head는 연결 리스트의 헤드다.
+ * 특정 노드가 리스트 내의 다른 노드와 next 포인트를 통해 연결되어 있을 때 이 리스트에는 사이클이 있다고 할 수 있다.
+ * pos는 next 포인터와 연결된 노드의 인덱스를 나타내는데 쓰이며 pos는 파라미터로 주어지지 않는다.
+ * 주어진 리스트에 사이클이 있다면 true를 그렇지 않다면 false를 반환하세요.
+ * */
+public class Solution {
+
+    // 시간복잡도: O(n), 공간복잡도: O(1)
+    public boolean hasCycle(ListNode head) {
+        if (head == null) {
+            return false;
+        }
+
+        ListNode next = head;
+        ListNode furtherNext = head;
+
+        while (furtherNext != null && furtherNext.next != null) {
+            next = next.next;
+            furtherNext = furtherNext.next.next;
+            if (next == furtherNext) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    // head 없을 때까지 계속 탐색 반복 : 시간복잡도, 공간복잡도 O(n)
+    // public boolean hasCycle(ListNode head) {
+
+    //     Set<ListNode> nodeSet = new HashSet<>();
+
+    //     while (head != null) {
+    //         if (nodeSet.contains(head)) {
+    //             return true;
+    //         }
+    //         nodeSet.add(head);
+    //         head = head.next;
+    //     }
+
+    //     return false;
+
+    // }
+}
+

linked-list-cycle/YoungSeok-Choi.java

@@ -0,0 +1,67 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class Solution {
+    public boolean hasCycle(ListNode head) {
+        Set<ListNode> nSet = new HashSet<>();
+
+        while (head != null) {
+            if (nSet.contains(head)) {
+                return true;
+            }
+
+            nSet.add(head);
+            head = head.next;
+        }
+
+        return false;
+    }
+}
+
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ * int val;
+ * ListNode next;
+ * ListNode(int x) {
+ * val = x;
+ * next = null;
+ * }
+ * }
+ */
+// NOTE: 같은 val의 다른 Node의 경우를 고려하지 못했다
+class WrongSolution {
+    public boolean hasCycle(ListNode head) {
+        Map<Integer, List<Integer>> vMap = new HashMap<>(); // NOTE: val, pos
+
+        if (head == null) {
+            return false;
+        }
+
+        ListNode cur = head;
+        boolean isCyclick = false;
+        int pos = -1;
+        while (cur != null) {
+
+            if (vMap.containsKey(cur.val)) {
+                isCyclick = true;
+                break;
+            }
+
+            List<Integer> posList = new ArrayList<>();
+            posList.add(pos++);
+            vMap.put(cur.val, posList);
+            cur = head.next;
+        }
+
+        if (isCyclick) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}