FU11M00N

[LeetCode] Clone Graph - Javascript

호IT — Thu, 14 Sep 2023 23:05:55 +0900

Clone Graph

[주어지는 그래프 복제하기]

제약 조건

The number of nodes in the graph is in the range [0, 100].
1 <= Node.val <= 100
Node.val is unique for each node.
There are no repeated edges and no self-loops in the graph.
The Graph is connected and all nodes can be visited starting from the given node.

Example

문제 접근 방식

node의 neighbors를 돌고 또 거기에 존재하는 neighbors가 존재하기에, 재귀 방식의 dfs로 문제 풀이가 가능했다.

visited 객체를 생성해 순회하고 있는 노드가 방문한 노드인지 확인한다.

node.val 값을 key로 지정해 주어지는 노드를 복제할 생각으로 코드를 작성했다.

처음 주어지는 노드를 복제하고, 해당 노드의 neighbors들을 재귀 호출해 복제를 한다.
만약 이미 visited 객체에 존재할 경우 리턴을 해 중복 순회가 일어나지 않도록 하고,
아니라면 해당 노드를 복제하고 visited에 등록한다.

node가 없을 경우 예외 처리를 위해 node가 null이라면 그대로 node를 리턴하도록 한다.

sovle 코드

/**
 * // Definition for a Node.
 * function Node(val, neighbors) {
 *    this.val = val === undefined ? 0 : val;
 *    this.neighbors = neighbors === undefined ? [] : neighbors;
 * };
 */

/**
 * @param {Node} node
 * @return {Node}
 */
var cloneGraph = function(node) {
    
    var visited = {};
    
    let dfs = function(node) {
        if (!node){
            return node;
        }

        if (visited[node.val]!=null){
            return visited[node.val];
        } 
        
        let root = new Node(node.val);

        visited[node.val] = root;

        for (let n of node.neighbors) {
            root.neighbors.push(dfs(n));
        }

        return root;
    }
    
    return dfs(node);
};

[LeetCode] Kth Largest Element in an Array - Javascript

호IT — Mon, 11 Sep 2023 23:33:57 +0900

Kth Largest Element in an Array

[정렬을 하지 않고 k 번째로 큰 수 찾기]

제약 조건

1 <= k <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4

Example

ex1) Input: nums = [3,2,1,5,6,4], k = 2
     Output: 5
 

ex2) Input: nums = [3,2,3,1,2,4,5,5,6], k = 4
     Output: 4

문제 접근 방식

정렬을 하지 않고 k 번째로 큰 값을 구하는 문제이다.
해당 문제는 Heapify의 특성을 이용해 문제를 풀이할 수 있다.

Heapify 작업은 마지막 노드의 부모 노드를 루트로 하는 서브 트리를 힙 조건을 만족하도록 조정하는 것이다.
이러한 특성을 이용해 서브 트리의 루트가 되는 노드를 하나씩 앞으로 이동하며 서브 트리를 힙로 하나씩 변경하는 행위를
bubble down이라고 한다.

또한, 해당 구조의 배열에서 왼쪽 자식 노드를 찾고 싶다면 arr[2i+1]을 하면 되고,

오른쪽 자식 노드는 arr[2i+2]를 하면 자식을 찾을 수 있다.

코드 설명은 아래와 같다.

맨 처음 배열의 중간 인덱스를 mid에 저장한다.
후에 bubbleDown 함수를 사용하며 배열을 정렬할 건데, 이때 시작점을 중간 인덱스로 시작하는 것이다.
그 후 반복문으로 중간 인덱스부터 시작하여 배열을 힙 구조로 정렬한다.

(현재 배열은 아무런 정렬도 되어있지 않은 무작위 배열이다.)
bubbleDown 함수 내에선, 주어지는 인덱스를 기준으로 힙 특성을 유지하도록 배열을 재정렬한다.

위의 특성을 이용해 왼쪽 자식과 오른쪽 자식을 비교하며 가장 큰 값을 가진 자식과 swap 함수를 호출해 교환을 하고,
bubbleDown 함수를 재귀 호출해 반복한다.
이렇게 for 반복문을 나오게 되면, 가장 큰 k의 값을 구하기 위해 while(k--)을 통해 가장 큰 값을 구하는 작업을 하는데,
swap(0, nums.length-1)를 통해 배열의 제일 처음 인덱스와 마지막 인덱스를 교환하면서 가장 큰 인덱스를 가진 배열로 이동시키고
해당 상태가 되었으면 result에 가장 큰 값을 저장한다.

그 후 bubbleDown(0)을 해주는 이유는 가장 큰 값을 가진 인덱스를 배열 맨 위로 오게 해서 다시 힙 구조를 유지하도록 해주는 것이다.

해당 문제를 풀이하기 위해, 혼자서 많은 시간을 고군분투하며 코드를 작성했었다.

뭔가 글로 작성하기 애매한 트러블이 많이 발생 해 이상한곳에서 시간을 많이 쏟기도 했었다.
대략적인 힙 코드는 작성했지만 테스트케이스 전부 통과가 되지 않는 경우가 발생해 다른 풀이를 참고하며,

코드의 구조나 틀린 곳은 조금 수정하여 풀었다..

solve 전체 코드

var findKthLargest = function (nums, k) {
   const mid = Math.floor(nums.length / 2);

   for (let i = mid; i >= 0; i--) {
      bubbleDown(i);
   }

   let result;

   while (k--) {
      swap(0, nums.length - 1);
      result = nums.pop();
      bubbleDown(0);
   }

   function bubbleDown(i) {
      const leftChild = 2 * i + 1;
      const rightChild = 2 * i + 2;
      let max = i;

      if (leftChild < nums.length && nums[leftChild] > nums[max]) {
         max = leftChild;
      }
      if (rightChild < nums.length && nums[rightChild] > nums[max]) {
         max = rightChild;
      }

      if (max !== i) {
         swap(i, max);
         bubbleDown(max);
      }
   }

   function swap(i, j) {
      [nums[i], nums[j]] = [nums[j], nums[i]];
   }

   return result;
};

[LeetCode] Implement Trie (Prefix Tree) - Javascript

호IT — Mon, 11 Sep 2023 20:16:03 +0900

Implement Trie (Prefix Tree)

[Trie 자료구조]

제약 조건

1 <= word.length, prefix.length <= 2000
word and prefix consist only of lowercase English letters.
At most 3 * 10^4 calls in total will be made to insert, search, and startsWith.

Example

ex1) Input
     ["Trie", "insert", "search", "search", "startsWith", "insert", "search"]
     [[], ["apple"], ["apple"], ["app"], ["app"], ["app"], ["app"]]
     Output
     [null, null, true, false, true, null, true

	Explanation
	Trie trie = new Trie();
	trie.insert("apple");
	trie.search("apple");   // return True
	trie.search("app");     // return False
	trie.startsWith("app"); // return True
	trie.insert("app");
	trie.search("app");     // return True

문제 접근 방식

트라이 자료구조는 문자열을 저장하고 탐색하기 위한 트리모양의 자료구조이다.

보통 문자열 탐색에 많이 사용된다.

다만, 문자마다 노드를 만들기에 저장공간이 많이 사용된다.

트라이 자료구조를 이용해 insert, search, startsWith를 구현해야한다.

구현할때 아래와 같은 특성을 고려해 풀이를 해야한다.

주어지는 예시를 봤을 때, trie.insert를 통해 'apple' 문자열을 삽입하고,
'apple' 문자열을 trie.search 했을 때 true가 리턴되며 'app'을 search 했을 땐 false가 리턴돼야 한다.
또 'app'문자열을 trie.startWith 했을 땐 true를 리턴하면 된다.

각각의 메서드 기능들은 아래와 같은 개념을 생각하며 구현했다.

insert

반복문을 사용해 각 노드를 탐색하면서,

현재 노드가 존재하지는 지 확인하고 존재한다면 이어서 탐색을 하고, 존재하지 않으면 새로운 노드를 생성한다.

탐색이 끝난 후 마지막에 있는 노드의 curr.isWord의 값을 true로 만들어 현재 문자열의 끝 지점이라는 것을 알려준다.

search

반복문을 사용해 각 노드를 탐색하면서,

현재 트라이에 해당 문자가 있는지 탐색한다.

만약 해당 문자가 존재하는 경우 계속 이어서 탐색하고 존재하지 않는다면 false를 리턴한다.

반복문이 종료될 때 해당 문자가 마지막인지 알려주는 isWord를 리턴해 true를 리턴한다.

startWith

반복문을 사용해 각 노드를 탐색하면서,

현재 트라이에 해당 문자가 있는지 탐색한다.

만약 해당 문자가 존재하는 경우 계속 이어서 탐색하고 존재하지 않는다면 false를 리턴한다.

반복문이 종료될 때 false가 리턴되지 않았다면 해당 문자열이 존재한다는 의미이기에 true를 리턴한다.(search 방법과 리턴 형식만 다름.)

solve 전체 코드

class TrieNode {
   constructor() {
      this.children = {};
      this.isWord = false;
   }
}

var Trie = function () {
   this.root = new TrieNode();
};

/**
 * @param {string} word
 * @return {void}
 */
Trie.prototype.insert = function (word) {
   let curr = this.root;
   for (let c of word) {
      if (curr.children[c] == null) {
         curr.children[c] = new TrieNode();
      }
      curr = curr.children[c];
   }

   curr.isWord = true;
};

/**
 * @param {string} word
 * @return {boolean}
 */
Trie.prototype.search = function (word) {
   let curr = this.root;
   for (let c of word) {
      if (curr.children[c] != null) {
         curr = curr.children[c];
      } else {
         return false;
      }
   }

   return curr.isWord;
};

/**
 * @param {string} prefix
 * @return {boolean}
 */
Trie.prototype.startsWith = function (prefix) {
   let curr = this.root;
   for (let c of prefix) {
      if (curr.children[c] != null) {
         curr = curr.children[c];
      } else {
         return false;
      }
   }

   return true;
};

/**
 * Your Trie object will be instantiated and called as such:
 * var obj = new Trie()
 * obj.insert(word)
 * var param_2 = obj.search(word)
 * var param_3 = obj.startsWith(prefix)
 */

[LeetCode] Average of Levels in Binary Tree - Javascript

호IT — Fri, 8 Sep 2023 02:22:25 +0900

Average of Levels in Binary Tree

[이진트리의 각 레벨에서의 평균 값 구하기]

제약 조건

The number of nodes in the tree is in the range [1, 10^4].
-2^31 <= Node.val <= 2^31 - 1

Example

문제 접근 방식

이전에 풀었던 방식처럼 재귀를 이용해서 풀면 될 것 같았다.

재귀 함수 내에서는 sms[level]에 값을 넣을 때 data.val의 합계를 넣는다

즉 각 레벨에서의 노드의 합계를 모두 더해 배열에 넣는다.

위의 사진을 예시로 했을 때, sum[3,29,22]가 들어가게 된다.
sum 배열의 0부터 2까지의 레벨은 각각 트리의 레벨을 의미한다.

cnt 배열에는 각 레벨의 노드의 개수가 들어간다.
예시로 들자면 cnt[1,2,2]가 들어가게 된다.

해당 연산을 하는 이유는 평균값을 구해야 하기에 노드의 개수를 저장하는 것이다.
재귀 호출이 모두 끝난 후 마지막으로 aver 배열에 합계를 구한
sum 배열과 노드의 개수가 들어간 cnt 변수를 나누기해 각 트리의 레벨의 평균값을 구한다.

solve 코드

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var averageOfLevels = function(root) {
    const cnt = [];
    const sums = [];
    const aver = [];
    const recursive = (data, level) => {
        if (!data){
            return null
        } 
        if (sums[level] == undefined) {
            sums[level] = 0
            cnt[level] = 0
        }
        sums[level] += data.val
        cnt[level] += 1

        recursive(data.left, level + 1)
        recursive(data.right, level + 1)
    }

    recursive(root, 0)

    for (let i=0; i<cnt.length; i++) {
        aver.push(sums[i]/cnt[i])
    }

    return aver;
};

[LeetCode] Binary Tree Right Side View - Javascript

호IT — Fri, 8 Sep 2023 01:48:46 +0900

Binary Tree Right Side View

[오른쪽 시야에서 트리 보기]

제약 조건

The number of nodes in the tree is in the range [0, 100].
-100 <= Node.val <= 100

Example

ex2) Input: root = [1,null,3]
     Output: [1,3]

ex3) Input: root = []
     Output: []

초기 문제 접근 방식

초기엔 문제 설명에 대해 이해가 잘 안가, 예시의 그림을 보고 대충 이해하고 풀었다.
단순히 오른쪽 노드를 모두 출력하는 줄 알고 아래와 같이 문제를 풀었고, 실제로 처음 주어지는 테스트케이스 3개는 풀었지만,
다른 테스트 케이스들은 풀지 못했다.

초기 접근 코드

var rightSideView = function(root) {
    const result = [];
    const queue = [];
    
    if (root === null) return result;
    
    queue.push(root);
    while(queue.length !== 0) {
        let size = queue.length;
        for (let i = 0; i < size; i++) {
            let n = queue.shift();
            if (i === size - 1) result.push(n.val);
            if (n.left !== null) queue.push(n.left);
            if (n.right !== null) queue.push(n.right);
        }
    }
    
    return result;
};

다시 생각 해보며

실패한 테스트케이스들을 보며 문제를 다시 이해 할 수 있었다.

위의 그림을 예시로, 만약 1,3,4 중 4가 없다고 가정 해보자.

그럼 리턴해야 할 값은 1,3,5가 된다. 4가 없어짐과 동시에 5가 보여지는것이다.

만약 1,3,4 중 3이 사라지면 1,4,5가 보여야한다. 4의 노드가 3의 자리에 들어가기에 5노드가 보이기 때문이다.

문제를 풀이하는데에 접근한 방법은 아래와 같다.

먼저 트리의 왼쪽에 있는 노드를 배열에 넣는다.

이 과정을 반복하며 트리의 왼쪽 끝에 도달 한 다음 값이 없으면 오른쪽 노드의 값으로 덮어 씌운다.

맨 왼쪽 노드를 모두 재귀 호출했을 땐
res 배열에 [1,2,5]가 들어가게 되고, 해당 노드가 존재하지 않을 때까지 순회했을 때,
오른쪽 노드를 재귀 호출해서 right 값으로 덮어씌우고 없으면 해당 값 그대로 존재하게 한다.
여기서 배열 3개의 인덱스는 각각의 레벨 0, 1, 2로 해석된다.
즉 현재 트리는 3,4가 존재하기에 기존에 존재하던 2,5는 3,4,로 덮어 쓰기가 되어 [1,3,4]가 된다.

solve 코드

function rightSideView(root) {    
    const res = []
    
    function traverse(node, level) {
        if (node?.val === undefined){
            return null
        } 

        res[level] = node.val
        
        traverse(node.left, level + 1)
        traverse(node.right, level + 1)
    }
    
    traverse(root, 0)
    
    return res
};

[LeetCode] Kth Smallest Element in a BST - Javascript

호IT — Fri, 8 Sep 2023 00:24:47 +0900

Kth Smallest Element in a BST

[이진 탐색 트리, k번째로 작은 수 찾기]

제약 조건

The number of nodes in the tree is n.
1 <= k <= n <= 10^4
0 <= Node.val <= 10^4

Example

문제 접근 방식

주어지는 트리가 이진 탐색 트리이고, k가 주어지면 k 번째로 작은 노드를 반환하면 되기에,
중위 순회 방법으로 쉽게 풀 수 있다.

중위 순회는 노드의 가장 왼쪽 - 루트 - 오른쪽 순으로 순회를 하는데,
이진 트리 탐색이기에, 가장 작은 수는 왼쪽부터 있는 특성을 이용해 풀 수 있었다.
먼저 재귀 함수를 만들어 root를 받아 data가 존재하지 않으면 리턴하는 제어문을 작성한다.

이후 노드의 맨 왼쪽부터 접근이 가능하도록 recusive 함수를 재귀 호출한다.
data.left가 존재할 때까지 재귀 호출을 하고 이후 index를 1씩 증가하며,
k와 값이 같은지 비교하고 같을 때 현재 노드의 값을 smallest 변수에 값을 넣고 리턴한다.

이후 data.right도 재귀 호출해 반복하여 값을 찾는다.

접근 코드

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} k
 * @return {number}
 */
var kthSmallest = function (root, k) {
   let index = 0;
   let smallest;
   const recursive = data => {
      if (!data) {
         return;
      }
      recursive(data.left);
      index++;
      if (index == k) {
         smallest = data.val;
         return;
      }
      recursive(data.right);
   };

   recursive(root);
   return smallest;
};

[LeetCode] Minimum Absolute Difference in BST - Javascript

호IT — Wed, 6 Sep 2023 22:47:48 +0900

Minimum Absolute Difference in BST

[이진 탐색 트리, 가장 짧은 간격 찾기]

제약 조건

The number of nodes in the tree is in the range [2, 10^4].
0 <= Node.val <= 10^5

Example

초기 문제 접근 방식

트리의 각각의 노드끼리 간격의 가장 작은 차이의 절댓값을 구하는 문제이다.

초기엔 서로 인접한 노드끼리에서만 간격 차이를 구하는 것으로 이해하여,
tmp 값에는 부모 노드의 값을 저장하고

tmp 값과 자식의 노드 왼쪽과 오른쪽을 빼기 연산을 하여 최솟값을 min 변수에 계속 저장하는 방식으로 코드를 작성했다.

recusive라는 함수를 생성해 tree 데이터를 받아 해당 데이터가 없으면 리턴을 한다.
그 후tmp 값과 data.val의 절댓값 차이를 구하고 min 값과 비교를 해 min에 저장한다.

data.left로 recusive 함수를 재귀 호출해 반복을 하고 data.left의 데이터가 null이면 데이터가 없다는 의미이기에,
왼쪽 연산 노드의 최솟값을 모두 구한 후 오른쪽 트리의 노드를 모두 호출해 반복해 min 값을 구한다.

위의 방식대로 풀이를 제출하면, 아래의 테스트 케이스에서 걸린다.
각각의 트리에 노드가 인접한 노드끼리의 간격이 아닌, 모든 노드 중 가장 작은 간격을 구하는 것이었다.

초기 접근 코드

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var getMinimumDifference = function (root) {
   let min = Number.MAX_SAFE_INTEGER;
   let tmp = -Infinity;

   const recursive = data => {
      if (!data) {
         return;
      }
      min = Math.min(min, Math.abs(tmp - data.val));
      tmp = data.val;
      recursive(data.left);
      recursive(data.right);
   };

   recursive(root);

   return min;
};

다시 생각 해보며

코드를 재작성하는데, 이전 코드와 큰 차이가 없었다.
recusive(data.left) 코드 한 줄을 위로 올려, 가장 왼쪽부터 모든 노드를 순회하도록 중위 순회를 하는 것이다.
이렇게 하면 이전 코드와 다르게 인접한 노드의 간격만 구하는 것이 아닌, 모든 노드의 간격의 최솟값을 구할 수 있었다.

이후 오른쪽 노드도 재귀 호출해 반복하여 최솟값을 구한다.

solve 코드

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var getMinimumDifference = function (root) {
   let min = Number.MAX_SAFE_INTEGER;
   let tmp = -Infinity;

   const recursive = data => {
      if (!data) {
         return;
      }
      recursive(data.left);
      min = Math.min(min, Math.abs(tmp - data.val));
      tmp = data.val;
      recursive(data.right);
   };

   recursive(root);

   return min;
};

[LeetCode] Find Minimum in Rotated Sorted Array - Javascript

호IT — Mon, 4 Sep 2023 23:38:52 +0900

Find Minimum in Rotated Sorted Array

[특정 값을 기준으로 뒤바뀌어 정렬이 되어 있는 배열의 target 찾기]

제약 조건

n == nums.length
1 <= n <= 5000
-5000 <= nums[i] <= 5000
All the integers of nums are unique.
nums is sorted and rotated between 1 and n times.

Example

ex1) Input: nums = [3,4,5,1,2]
     Output: 1
     Explanation: The original array was [1,2,3,4,5] rotated 3 times.

ex2) Input: nums = [4,5,6,7,0,1,2]
     Output: 0
     Explanation: The original array was [0,1,2,4,5,6,7] and it was rotated 4 times.


ex3) Input: nums = [11,13,15,17]
     Output: 11
     Explanation: The original array was [11,13,15,17] and it was rotated 4 times.

문제 접근 방식

정렬이 되어있지만, 특정 인덱스를 기준으로 돌아간 배열이 주어졌을 때, 최솟값을 구하는 문제이다.

만약 start가 end보다 작거나 같다면 해당 배열은 정렬이 되어있다는 의미로 while 문을 탈출해 nums[start]를 리턴해 정답을 풀이한다.

      if (nums[start] <= nums[end]) {
         break;
      }

nums[start]가 nums[mid]보다 작거나 같다면, 배열의 절반 중 왼쪽은 정렬이 되어있다고 봐도 된다.
즉 해당 제어문이 true라면 start를 mid+1로 업데이트하고, 아니라면 end를 mid로 업데이트한다.
해당 제어문을 반복하며 nums[stasrt]가 nums[end]보다 작거나 같을 때까지 즉 배열이 정렬되어 있을 때까지,

start와 end의 값을 초기화한다.

      let mid = Math.floor((start + end) / 2);
      if (nums[start] <= nums[mid]) {
         start = mid + 1;
      } else {
         end = mid;
      }

sovle 코드

var findMin = function (nums) {
   let start = 0,
      end = nums.length - 1;
   while (start <= end) {
      if (nums[start] <= nums[end]) {
         break;
      }
      let mid = Math.floor((start + end) / 2);
      if (nums[start] <= nums[mid]) {
         start = mid + 1;
      } else {
         end = mid;
      }
   }
   return nums[start];
};

[LeetCode] Search in Rotated Sorted Array - Javascript

호IT — Mon, 4 Sep 2023 23:11:56 +0900

Search in Rotated Sorted Array

[특정 값을 기준으로 뒤바뀌어 정렬이 되어 있는 배열의 target 찾기]

제약 조건

1 <= nums.length <= 5000
-10^4 <= nums[i] <= 10^4
All values of nums are unique.
nums is an ascending array that is possibly rotated.
-10^4 <= target <= 10^4

Example

ex1) Input: nums = [4,5,6,7,0,1,2], target = 0
     Output: 4

ex2) Input: nums = [4,5,6,7,0,1,2], target = 3
     Output: -1

ex3) Input: nums = [1], target = 0
     Output: -1

문제 접근 방식

You must write an algorithm with O(log n) runtime complexity.

해당 문제는 O(log n)으로 풀이 해야 하기에 이진 탐색이 필요하다고 생각했다.

num[start]가 nums[mid]보다 작다면 start부터 mid까지의 정렬이 정상적으로 되어있다는 의미이다.
ex) [4,5,6,7,0,1,2]
정렬이 제대로 되어 있는 상태에서 nums[start]가 target보다 작고 target이 nums[mid]보다 작으면
target과 mid 사이의 결괏값이 있을 거라고 추측이 가능하다는 의미이기에 end를 mid-1로 업데이트한다.
(배열의 절반 중 왼쪽을 선택한다는 의미.)
아니라면 오른쪽을 선택한다는 의미로 start를 mid+1로 초기화한다.

       if (nums[start] <= nums[mid]) {
           if (nums[start] <= target && target < nums[mid]) {
               end = mid - 1;
           } else {
               start = mid + 1;
           }
       } else {
           if (nums[mid] < target && target <= nums[end]) {
               start = mid + 1;
           } else {
               end = mid - 1;
           }
       }

sovle 코드

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function(nums, target) {
   let start = 0, end = nums.length - 1;

   while (start <= end) {
       let mid = Math.floor((start + end) / 2);

       if (nums[mid] === target) {
           return mid;
       }

       if (nums[start] <= nums[mid]) {
           if (nums[start] <= target && target < nums[mid]) {
               end = mid - 1;
           } else {
               start = mid + 1;
           }
       } else {
           if (nums[mid] < target && target <= nums[end]) {
               start = mid + 1;
           } else {
               end = mid - 1;
           }
       }
   }

   return -1;
};

[LeetCode] Merge Sorted Array - Javascript

호IT — Mon, 4 Sep 2023 22:28:30 +0900

Find Peak Element

[양옆의 요소와 비교해 큰 수 인지 확인]

제약 조건

1 <= nums.length <= 1000
-2^31 <= nums[i] <= 2^31 - 1
nums[i] != nums[i + 1] for all valid i.

Example

ex1) Input: nums = [1,2,3,1]
     Output: 2
     Explanation: 3 is a peak element and your function should return the index number 2.

ex2) Input: nums = [1,2,1,3,5,6,4]
     Output: 5
     Explanation: Your function can return either index number 1 where the peak element is 2, or index number 5 where the peak element is 6.

문제 접근 방식

문제 설명에 Y"ou may imagine that nums[-1] = nums[n] = -∞"라는 설명이 있다.
즉 nums 배열의 -1 인덱스와 n 인덱스는 가장 최솟값을 가진다고 되어 있다는 의미이다.
이 점을 생각해 해당 문제를 이진 탐색으로 풀 수 있다.

맨 처음 while 반복문으로 start가 end보다 커질 때 까지 반복한다.

mid는 배열의 중간의 값으로 초기화 되도록
mid = Math.floor((start + end) / 2); 연산을 수행한다.

그 후 mid의 이전 인덱스와 이후 인덱스를 비교해 mid가 양옆 요소보다 큰지 확인하고 크다면 해당 인덱스를 리턴한다.
만약 아니라면 mid의 요소 값이 left 보다 크다면 end를 mid-1로 값을 업데이트하고, 작다면 start를 mid+1 값으로

업데이트를 하여 절반을 날려버린다.

이런 방식으로 접근하면 왼쪽이나 오른쪽의 절반 중 한쪽에 요소가 양옆보다 큰 수가 없어 다른 한쪽을 버려버리면 안 될 것 같지만,
이렇게 해도 되는 이유는 nums[-1]과 nums[n] 인덱스는 -Infinity 값을 가지기 때문에 배열의 맨 끝까지 가게 되면 어차피 최솟값과 요소의 값을 비교하기에 무조건 양옆보다 큰 요소가 나온다.

solve 전체 코드

/**
 * @param {number[]} nums
 * @return {number}
 */
var findPeakElement = function(nums) {
    let start = 0, end = nums.length - 1
    let mid = 0;
    
    while (start <= end) {
        mid = Math.floor((start + end) / 2);
        
        const val = nums[mid];
        const left = nums[mid - 1] || -Infinity
        const right = nums[mid + 1] || -Infinity
        
        if (val > left && val > right) return mid;
        if (left > val) {
            end = mid - 1
        } else {
            start = mid + 1
        }
    }

    return 0;
};