feat: solve top-k

Author: sujeong-dev

contains-duplicate/sujeong-dev.js

@@ -1,9 +1,16 @@
 /**
  * @param {number[]} nums
  * @return {boolean}
+ * 
+ * 시간복잡도 계산
+ * 입력 크기(n)가 커질 때 연산 횟수가 n에 비례해서 증가
+ * => O(n)
+ * 
+ * 공간복잡도 계산
+ * indices가 nums에 비례해서 할당
+ * 상수 i 할당
+ * => O(n)
  */
-
-// for loof: O(n)
 var containsDuplicate = function (nums) {
   let indices = {};
   nums.forEach((num, index) => {
@@ -17,7 +24,19 @@ var containsDuplicate = function (nums) {
   return false;
 };
 
-// size 속성: O(1)
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ * 
+ * 시간복잡도 계산
+ * Set의 size속성은 입력 크기와 관계없이 일정한 시간이 걸림
+ * => O(1)
+ * 
+ * 공간복잡도 계산
+ * indices가 nums에 비례해서 할당
+ * 상수 i 할당
+ * => O(n)
+ */
 var containsDuplicate = function (nums) {
   const indices = new Set(nums);
 

top-k-frequent-elements/sujeong-dev.js

@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ * 
+ * 시간복잡도 계산
+ * for loop가  O(n)
+ * reduce가 O(n)
+ * sort가 O(n log n)
+ * => O(n log n)
+ */
+var topKFrequent = function (nums, k) {
+  let result = [];
+  for (let i = 0; i < nums.length; i++) {
+    if (result.find((el) => el.key == nums[i])) continue;
+    const count = nums.reduce((cnt, el) => cnt + (nums[i] === el), 0);
+    result.push({ key: nums[i], value: count });
+  }
+
+  return result
+    .sort((a, b) => b.value - a.value)
+    .slice(0, k)
+    .map((el) => el.key);
+};
+
+/**
+ * Follow up: Your algorithm's time complexity must be better than O(n log n), where n is the array's size.
+ */

two-sum/sujeong-dev.js

@@ -2,9 +2,16 @@
  * @param {number[]} nums
  * @param {number} target
  * @return {number[]}
+ * 
+ * 시간복잡도 계산
+ * 입력 크기(n)가 커질 때 연산 횟수가 n^2에 비례해서 증가
+ * => O(n^2)
+ * 
+ * 공간복잡도 계산
+ * 상수 i 할당
+ * 상수 j 할당
+ * => o(1)
  */
-
-// 2중 for문: O(n^2)
 var twoSum = function (nums, target) {
   for (let i = 0; i < nums.length; i++) {
     for (let j = 0; j < nums.length; j++) {
@@ -14,7 +21,20 @@ var twoSum = function (nums, target) {
   }
 };
 
-// for loof: O(n)
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ * 
+ * 시간복잡도 계산
+ * 입력 크기(n)가 커질 때 연산 횟수가 n에 비례해서 증가
+ * => O(n)
+ * 
+ * 공간복잡도 계산
+ * result가 nums에 비례해서 할당
+ * 상수 i, findNum 할당
+ * => O(n)
+ */
 var twoSum = function (nums, target) {
   let result = {};