시간/공간 복잡도 테스트용 PR (리뷰 불가능)

design-add-and-search-words-data-structure/lkhoony.js

@@ -0,0 +1,67 @@
+const Node = function() {
+    this.children = {};
+    this.isEnd = false;
+}
+
+var WordDictionary = function() {
+    this.root = new Node();
+};
+
+/**
+ * @param {string} word
+ * @return {void}
+ */
+WordDictionary.prototype.addWord = function(word) {
+    let currentNode = this.root;
+
+    for (let char of word) {
+        if (!currentNode.children[char]) {
+            currentNode.children[char] = new Node();
+        }
+        currentNode = currentNode.children[char];
+    }
+
+    currentNode.isEnd = true;
+};
+
+/**
+ * @param {string} word
+ * @return {boolean}
+ */
+WordDictionary.prototype.search = function(word) {
+    if (word === undefined) return false;
+    return this._search(this.root, word, 0);
+};
+
+WordDictionary.prototype._search = function(node, word, index) {
+    if (index === word.length) {
+        return node.isEnd;
+    }
+
+    const char = word[index];
+
+    if (char !== '.') {
+        const child = node.children[char];
+        return child ? this._search(child, word, index + 1) : false;
+    }
+
+    for (const key in node.children) {
+        if (this._search(node.children[key], word, index + 1)) {
+            return true;
+        }
+    }
+
+    return false;
+};
+
+/**
+ * Your WordDictionary object will be instantiated and called as such:
+ * var obj = new WordDictionary()
+ * obj.addWord(word)
+ * var param_2 = obj.search(word)
+ */
+
+// n: 단어수, m: 단어 길이
+// addWord: 시간 복잡도 O(m)
+// search: 	시간 복잡도 O(m^2)
+// 공간 복잡도 O(n * m)

find-minimum-in-rotated-sorted-array/lkhoony.js

@@ -0,0 +1,43 @@
+// math의 min을 이용하는 방법
+// tc: O(n^4)
+// sc: 잘 몰랐는데 모든 요소를 함수 인자로 풀어 콜스택에 올린다 하여 O(n)이 된다고 함..
+// (대용량의 배열 시 maximum exceed 에러가 날 수 있음)
+const findMin_use_math_min = function (nums) {
+  return Math.min(...nums);
+};
+
+// 메서드를 사용하지 않은 풀이.
+// tc: O(n^6)
+// sc: O(1)
+const findMin_naive = function (nums) {
+  let min = nums[0];
+
+  for (let i = 1; i < nums.length; i++) {
+    if (nums[i] <= min) {
+      min = nums[i];
+      break;
+    }
+  }
+
+  return min;
+};
+
+// 시간복잡도를 문제의 요구사항에 맞도록 줄여본 풀이
+// tc: O(n^2*logn)
+// sc: O(1)
+const findMin = function (nums) {
+  let left = 0,
+    right = nums.length - 1;
+
+  while (left < right) {
+    let mid = Math.floor((left + right) / 2);
+
+    if (nums[mid] > nums[right]) {
+      left = mid + 1;
+    } else {
+      right = mid;
+    }
+  }
+
+  return nums[left];
+};

graph-valid-tree/lkhoony.js

@@ -0,0 +1,38 @@
+export class Solution {
+    /**
+     * @param {number} n - number of nodes
+     * @param {number[][]} edges - undirected edges
+     * @return {boolean}
+     */
+    validTree(n, edges) {
+      if (n === 0) return true;
+
+      // 인접 리스트 생성
+      const adj = {};
+      for (let i = 0; i < n; i++) {
+        adj[i] = [];
+      }
+      for (const [n1, n2] of edges) {
+        adj[n1].push(n2);
+        adj[n2].push(n1);
+      }
+
+      const visit = new Set();
+
+      const dfs = (i, prev) => {
+        if (visit.has(i)) return false;
+
+        visit.add(i);
+
+        for (const j of adj[i]) {
+          if (j === prev) continue;
+          if (!dfs(j, i)) return false;
+        }
+
+        return true;
+      };
+
+      return dfs(0, -1) && visit.size === n;
+    }
+  }
+

linked-list-cycle/lkhoony.ts

@@ -0,0 +1,32 @@
+/**
+ * Definition for singly-linked list.
+ * 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)
+ *     }
+ * }
+ */
+
+/*
+리스트 노드를 저장하는 Map을 생성, 노드를 탐색하며 해당 Map에 노드를 저장하고 이미 있는 노드일 경우 true 리턴
+
+시간복잡도 : O(N) - N은 리스트의 개수
+공간복잡도 : O(N) - Map 객체
+*/
+
+function hasCycle(head: ListNode | null): boolean {
+  const nodeMap = new Map<ListNode, boolean>()
+
+  while (head) {
+    if (nodeMap.get(head) === true) {
+      return true
+    }
+    nodeMap.set(head, true)
+    head = head.next
+  }
+
+  return false
+}

pacific-atlantic-water-flow/lkhoony.ts

@@ -0,0 +1,79 @@
+/**
+pacific에 닿을 수 있는 grid를 판별하는 이중 배열과 atlantic에 닿을 수 있는지를 판별하는 이중 배열을 생성한다.
+pacific 배열은 r, c 중 하나라도 0일 경우 true값,
+atlantic 배열은 r, c 중 하나라도 length값과 같을 경우 true값을 채운다
+
+이후 r, c 탐색을 돌며 pacific/ atlantic true인 값이 있으면 dfs를 돌린다
+ - 이전 heights값보다 크거나 같으면 true 처리, 인접한 셀을 또 dfs 탐색
+
+두 배열값이 둘 다 true인 위치들을 리턴한다
+
+시간복잡도 : O(M*N) - 순회
+ */
+
+function pacificAtlantic(heights: number[][]): number[][] {
+  const m = heights.length
+  const n = heights[0].length
+  const result = []
+  const pacificChecker = Array.from({ length: m }).map((el, idx) => {
+    if (idx === 0) {
+      return new Array(n).fill(true)
+    } else {
+      const arr = new Array(n).fill(false)
+      arr[0] = true
+      return arr
+    }
+  })
+  const atlanticChecker = Array.from({ length: m }).map((el, idx) => {
+    if (idx === m - 1) {
+      return new Array(n).fill(true)
+    } else {
+      const arr = new Array(n).fill(false)
+      arr[n - 1] = true
+      return arr
+    }
+  })
+
+  const dx = [0, 1, -1, 0]
+  const dy = [1, 0, 0, -1]
+
+  const search = (row, col, checker, stdValue) => {
+    const value = heights[row][col]
+    if (value < stdValue) return
+
+    checker[row][col] = true
+
+    for (let i = 0; i < 4; i++) {
+      const newRow = row + dx[i]
+      const newCol = col + dy[i]
+      if (newRow < 0 || newRow >= m) continue
+      if (newCol < 0 || newCol >= n) continue
+      if (checker[newRow][newCol]) continue
+
+      search(newRow, newCol, checker, value)
+    }
+  }
+
+  // dfs 탐색
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      if (pacificChecker[i][j]) {
+        search(i, j, pacificChecker, heights[i][j])
+      }
+      if (atlanticChecker[i][j]) {
+        search(i, j, atlanticChecker, heights[i][j])
+      }
+    }
+  }
+
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      if (pacificChecker[i][j] && atlanticChecker[i][j]) {
+        result.push([i, j])
+      }
+    }
+  }
+
+  //pacific, atlantic 모두 true인 인덱스배열 반환
+  return result
+}

reverse-bits/lkhoony.rs

@@ -0,0 +1,12 @@
+// TC: O(1)
+// SC: O(1)
+impl Solution {
+    pub fn reverse_bits(n: u32) -> u32 {
+        let mut res: u32 = 0;
+        for i in 0..32 {
+            let bit = (n >> i) & 1;
+            res += bit << (31 - i);
+        }
+        res
+    }
+}