학습하는 분들께 도움이 되고, 더 좋은 답변을 드릴 수 있도록 질문전에 다음을 꼭 확인해주세요.1. 강의 내용과 관련된 질문을 남겨주세요.2. 인프런의 질문 게시판과 자주 하는 질문(링크)을 먼저 확인해주세요.(자주 하는 질문 링크: https://bit.ly/3fX6ygx)3. 질문 잘하기 메뉴얼(링크)을 먼저 읽어주세요.(질문 잘하기 메뉴얼 링크: https://bit.ly/2UfeqCG)질문 시에는 위 내용은 삭제하고 다음 내용을 남겨주세요.=========================================[질문 템플릿]1. 강의 내용과 관련된 질문인가요? (예/아니오)2. 인프런의 질문 게시판과 자주 하는 질문에 없는 내용인가요? (예/아니오)3. 질문 잘하기 메뉴얼을 읽어보셨나요? (예/아니오)[질문 내용]여기에 질문 내용을 남겨주세요.

안녕하세요.HashSet의 toString 코드를 보다 문의사항이 있어 질문합니다. @Override public String toString() { return "MyHashSetV2{" + "buckets=" + Arrays.toString(buckets) + ", size=" + size + ", capacity=" + capacity + '}'; }다음과 같이 되어 있고 출력을 MyHashSetV2{buckets=[[Member{id='hi'}, Member{id='JPA'}], [], [], [], [], [], [Member{id='spring'}], [], [], [Member{id='java'}]], size=4, capacity=10} 이렇게 하니까 Arrays.toString(buckets) 부분이 [[Member{id='hi'}, Member{id='JPA'}], [], [], [], [], [], [Member{id='spring'}], [], [], [Member{id='java'}]]이 부분일텐데 따라 들어가면 toString 오버라이딩 된 형태가 toString(Object[] a) {다음과 같고 실제 스트링으로 만드는 코드는 StringBuilder b = new StringBuilder(); b.append('['); for (int i = 0; ; i++) { b.append(String.valueOf(a[i]));이거인데요.여기서 말하는 a[i]는 LinkedList<Object>[] set의 각각의 인덱스에 위치한 LinkedList<Object> 일텐데 LinkedList나 상위의 List를 타고 들어가봐도 따로 toString 메서드를 살펴볼 수 없습니다. String.valueOf(LinkedList)가 어떻게 동작하는건가요 ? 출력물 보면 각 LinkedList안에 객체로 들어간 member의 toString을 출력하는 거 같기는 한데 LinkedList를 순차척으로 도는 코드를 확인 못하겠습니다.감사합니다.

안녕하세요.MyHashSetV1()에서 작성한 코드를 중복으로 작성하지 않기 위해 MyHashSetV1(int capacity)에는 기본 생성자를 바디의 최상단이 아닌 곳에서 선언했더니 에러가 나는데, 이게 예전에도 안된다고 설명은 해주셨는데 왜 안되는지가 문득 궁금하네요.설명 부탁드립니다.감사합니다.public MyHashSetV1(int capacity){ this.capacity = capacity; this(); }

안녕하세요,여러 번 이해하려 해도 기초가 부족해 쉽게 이해되지 않아 질문을 남깁니다 ㅠㅠ // Member 클래스에서 equals() 오버라이딩 Member m1 = new Member("A"); Member m2 = new Member("A"); // m1.equals(m2) = trueHashAndEqualsMain3 수업 중 Member 클래스에서 새로 정의한 equals() 메서드를 통해 참조값이 다른 두 객체 m1.equals(m2) = true 를 알 수 있었습니다.  MyHashSetV2 에서 정의한 add() 메서드에서는 중복을 허용하지 않기 위해 LinkedList.contain() 메서드를 사용해서 안에 들어있는 내용의 동등성을 비교하고 있습니다.public boolean add(Object value) { int hashIndex = hashIndex(value); LinkedList<Object> bucket = buckets[hashIndex]; if (bucket.contains(value)) { return false; bucket.add(value); size++; return true; } equals() 를 재정의 하지 않은 MemberOnlyHash 를 이용한 HashAndEqualsMain2 수업에서는 m1 과 m2 가 Objects.equal() 로 다른 참조값을 비교하게 되어 add() 에서 중복을 검증할 수 없었고 MyHashSetV2.add() 를 통과해 같은 인덱스에 중복된 값이 들어가게 되었습니다. HashAndEqualsMain3 수업에서는 equals() 를 재정의한 Member 객체를 쓰고 있는데 m1 을 LinkedList 에 add() 로 추가한 후 m2 를 추가하는 과정에서 LinkedList.contains() 로 중복이 걸러져 m2 는 추가되지 않는것을 확인하게 되었습니다. 질문 : equals() 를 재정의 하며 Member 객체끼리 비교는 가능하게 되었는데 어떻게 Member 에서 재정의한 equals() 가 LinkedList.contains() 의 값에 영향을 줄 수 있는지 궁금합니다.Member 에서만 재정의한 메서드가 이미 LinkedList bucket 에 들어있는 "A" 라는 값과 동등성 검사를 할 때 영향을 끼치는 것 같은데 매개변수의 타입에서 재정의를 하는것이 LinkedList.contains() 에 영향을 미칠 수 있나요?혹은 영한님이 MyHashSetV2Main2 수업때 언급하신 equals() 사용처에 짧게 나온 아래 코드와 같은 동작 원리일까요?public boolean contains(Object searchValue) { int hashIndex = hashIndex(searchValue); LinkedList<Object> bucket = buckets[hashIndex]; for (Object object : bucket) { if (object.equals(searchValue)) { return true; } } return false; } 이해가 잘 되지 않아 질문도 뒤죽박죽인듯 해 걱정입니다. ㅠㅠ잘못 이해한 부분이 있다면 따끔한 지적 부탁드립니다. 항상 강의 잘 보고 있습니다!

안녕하세요. HashMap에서 values 메서드는 인터페이스를 반환하는데 Collection 인터페이스를 익명으로 구현 후 반환하나요? 아님 인터페이스 하위에 있는 구현 객체를 생성 후 반환하나요? 아님 크게 중요하지 않는 것인지,,HashMap에서 values 메서드를 보니 아래와 같이 되어 있더라고요.public Collection<V> values() { Collection<V> vs = values; if (vs == null) { vs = new Values(); values = vs; } return vs; } 감사합니다.

안녕하세요.LinkedList 구현 시 질문이 있어 글 남깁니다.기능 구현 관련된 건 아니고 제네릭 타입으로 변환 과정에서 의문이 가는게 있어서요.remove method 구현시에 제네릭 타입 전에는 다음과 같이 removeNode.item = removeNode.next = null; 라고 작성했거든요 ?어차피 둘 다 null일테니 ... 근데 이건 따로 에러가 안나고 제네릭 타입으로 변환하고 나서는 에러가 나네요 ?  확인 부탁드립니다.public Object remove(int index){ Node removeNode = getNode(index); Object removedItem = removeNode.item; if(index == 0){ first = removeNode.next; } else{ Node prevNode = getNode(index - 1); prevNode.next = removeNode.next; } /*removeNode.item = removeNode.next = null;*/ /*Node prevNode = getNode(index - 1); prevNode.next = removeNode.next;*/ removeNode.item = removeNode.next = null; size--; return removedItem; }public E remove(int index){ Node<E> removeNode = getNode(index); E removedItem = removeNode.item; if(index == 0){ first = removeNode.next; } else{ Node<E> prevNode = getNode(index - 1); prevNode.next = removeNode.next; } /*removeNode.item = removeNode.next = null;*/ /*Node prevNode = getNode(index - 1); prevNode.next = removeNode.next;*/ removeNode.item = removeNode.next = null; //이게 왜 에러일까요 ? 어차피 둘 다 null인 건 마찬가지인데요. size--; return removedItem; } 

Lowest common ancestor of a binary tree문제에서 아래 코드가 정답 코드로 알고 있는데,# Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution: def lowestCommonAncestor( self, root: "TreeNode", p: "TreeNode", q: "TreeNode" ) -> "TreeNode": if root == None: return None left = self.lowestCommonAncestor(root.left, p, q) right = self.lowestCommonAncestor(root.right, p, q) if root.val == p.val or root.val == q.val: return root elif left and right: return root else: return left or right # elif left: # return left # elif right: # return right # else: # reutrn None위 코드에서 아래 부분을 해주는 이유가 무엇인지 궁금합니다.if root.val == p.val or root.val == q.val: return root elif left and right: return root else: return left or right

class MinHeap { // 최소힙 arr = []; #reheapUp(index) { if (index > 0) { const parentIndex = Math.floor((index - 1) / 2); if (this.arr[index] < this.arr[parentIndex]) { const tmp = this.arr[index]; this.arr[index] = this.arr[parentIndex]; this.arr[parentIndex] = tmp; this.#reheapUp(parentIndex); } } } insert(value) { const index = this.arr.length; this.arr[index] = value; // 마지막에 값을 넣어준다. this.#reheapUp(index); } #reHeapDown(index) { const leftIndex = index * 2 + 1; // 왼쪽 Index if (leftIndex < this.arr.length) { // 만약에 왼쪽 인덱스가 총 배열의 길이보다 작은경우 const rightIndex = index * 2 + 2; const smaller = this.arr[leftIndex] > this.arr[rightIndex] ? leftIndex : rightIndex; if (this.arr[index] < this.arr[smaller]) { const temp = this.arr[index]; this.arr[index] = this.arr[smaller]; this.arr[smaller] = temp; this.#reHeapDown(smaller); } } } remove() { // root만 remove if (this.arr.length === 0) { return false; } if (this.arr.length === 1) { // 마지막 하나 남으면 pop해서 리턴해주기 return this.arr.pop(); } const root = this.arr[0]; this.arr[0] = this.arr.pop(); this.#reHeapDown(0); return root; } sort() { // 힙 정렬 const sortedArray = []; while (this.arr.length > 0) { sortedArray.push(this.remove()); } return sortedArray; } search(value) { for (let i = 0; i < this.arr.length; i++) { if (arr[i] === value) { return i; } } } } const minheap = new MinHeap(); minheap.insert(78); minheap.insert(56); minheap.insert(45); minheap.insert(32); minheap.insert(23); minheap.insert(19); minheap.insert(8); console.log(minheap.arr); minheap.remove(); minheap.remove(); minheap.remove(); minheap.remove(); minheap.remove(); minheap.remove(); 최대힙 코드를 최소힙 구하기 코드로 바꿔봤습니다. 질문1) 최소힙 구하기 remove 코드가 맞을까요?질문2) 최대힙이든 최소힙이든 sort 메서드가 sort 메서드 호출시 remove 메서드를 while문 루프로 호출하여서 sort 메서드 실행 후에 this.arr가 당연하게 빈배열이 되는데 while문 전에 this.arr를 변수에 담아두었다가 while 루프가 끝난후에 다시 this.arr 멤버변수에 넣어주어야 하는거 아닌가 궁금합니다.

안녕하세요.ObjectBox를 활용하여 int와 String을 받는 과정에서 중복은 해결하였으나 잘못된 타입을 넣을 경우에 대한 예시 들었던 부분에서 질문입니다.integerBox.set("문자100"); Integer result = (Integer)integerBox.get();이 부분에서 문의드릴게 실제 컴파일을 하기 전까지는 ide에서 에러라고 인식을 못하던데 왜 그런걸까요 ? get()을 통해 리턴되는게 object 타입이어도 실제 객체가 Integer 객체가 아니면 저렇게 (Integer)로 캐스트 하는 것 부터가 문제가 되야 할 거 같아서요. 감사합니다.

import java.util.*; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int n = sc.nextInt(); int[] x = new int[1000001]; int[] y = new int[1000001]; // 첫 번째 꼭짓점 int firstW = sc.nextInt() + 500000; int prevH = sc.nextInt() + 500000; int prevW = firstW; // 나머지 꼭짓점 for (int i = 1; i < n; i++) { int w = sc.nextInt() + 500000; int h = sc.nextInt() + 500000; if (prevW == w) { // 수직선 y[Math.min(prevH, h)]++; y[Math.max(prevH, h)]--; } else { // 수평선 x[Math.min(prevW, w)]++; x[Math.max(prevW, w)]--; } prevW = w; prevH = h; } // 마지막 꼭짓점과 첫 번째 꼭짓점 연결 if (prevW == firstW) { // 수직선 y[Math.min(prevH, firstW)]++; y[Math.max(prevH, firstW)]--; } else { // 수평선 x[Math.min(prevW, firstW)]++; x[Math.max(prevW, firstW)]--; } // 큰 값 찾기 int xMax = 0; int yMax = 0; for (int i = 1; i < 1000001; i++) { x[i] += x[i - 1]; // 이전 값이랑 누적합 y[i] += y[i - 1]; xMax = Math.max(x[i], xMax); // 큰 값 비교 yMax = Math.max(y[i], yMax); } System.out.println(Math.max(xMax, yMax)); } }안녕하세요 17611번 문제 자바로 풀고있습니다.백준 게시판과 인터넷에 공유된 풀이가 거의 없어 커뮤니티에 질문 올리게 되었습니다. 문제에서 주어진 예를 테스트 했을 때는 잘 작동하는데, 제출시에(40%쯤) '틀렸습니다' 라고 나옵니다. 해당 코드로는 작동하지 않는 반례 또는 식의 오류를 알려주세요. 감사합니다.

class Heap { arr = []; #reheapUp(index) { if (index > 0) { const parentIndex = Math.floor((index - 1) / 2); if (this.arr[index] > this.arr[parentIndex]) { // 값 바꾸기 const tmp = this.arr[index]; this.arr[index] = this.arr[parentIndex]; this.arr[parentIndex] = tmp; this.#reheapUp(parentIndex); } } } #reheapDown(index) { if (index > 0) { const parentIndex = Math.floor((index - 1) / 2); if (this.arr[index] < this.arr[parentIndex]) { const tmp = this.arr[index]; this.arr[index] = this.arr[parentIndex]; this.arr[parentIndex] = tmp; this.#reheapDown(parentIndex); } } } insert(value) { const index = this.arr.length; this.arr[index] = value; // 마지막에 값을 넣어준다. this.#reheapUp(index); } insertDown(value) { const index = this.arr.length; this.arr[index] = value; this.#reheapDown(index); } remove() { // root만 remove } search(value) { for (let i = 0; i < this.arr.length; i++) { if (arr[i] === value) { return i; } } } } const heap = new Heap(); heap.insert(8); heap.insert(19); heap.insert(23); heap.insert(32); heap.insert(45); heap.insert(56); heap.insert(78); const downHeap = new Heap(); downHeap.insertDown(78); downHeap.insertDown(56); downHeap.insertDown(45); downHeap.insertDown(32); downHeap.insertDown(23); downHeap.insertDown(19); downHeap.insertDown(8); console.log(downHeap.arr);reheapDown 이라는걸 만들어서 최소힙 만들기를 해보았는데 부모 index의 값과 비교하는 조건문의 부등호 방향만 바꾸니까 되는데 이게 맞나요...? 

 학습하는 분들께 도움이 되고, 더 좋은 답변을 드릴 수 있도록 질문전에 다음을 꼭 확인해주세요.1. 강의 내용과 관련된 질문을 남겨주세요.2. 인프런의 질문 게시판과 자주 하는 질문(링크)을 먼저 확인해주세요.(자주 하는 질문 링크: https://bit.ly/3fX6ygx)3. 질문 잘하기 메뉴얼(링크)을 먼저 읽어주세요.(질문 잘하기 메뉴얼 링크: https://bit.ly/2UfeqCG)질문 시에는 위 내용은 삭제하고 다음 내용을 남겨주세요.=========================================[질문 템플릿]1. 강의 내용과 관련된 질문인가요? (예/아니오)2. 인프런의 질문 게시판과 자주 하는 질문에 없는 내용인가요? (예/아니오)3. 질문 잘하기 메뉴얼을 읽어보셨나요? (예/아니오)[질문 내용]여기에 질문 내용을 남겨주세요.for (int i = 0; i < numbers.size(); i++) { System.out.print(numbers.get(i)); if(i<numbers.size()-1){ System.out.print(", "); } }i < number.size()-1 쪽이 제대로 이해가 안되는거같아서 질문합니다.정수 입력을 1,2,3 입력했으면 numbers.size() = 3i값 = 0 , numbers.size =3i값 = 1 , numbers.size = 3마지막 반복인 i값 = 2 , numbers.size = 3 을 할때는2<3-1 은 맞지않으니 마지막 3뒤에 " , " 출력안됨제가 이해한게 맞을까요 ?  

강의 내용중 Comparable, Comparator 파트에서 List 데이터를 정렬할 때 Collections.sort() 와 list.sort() 중 list.sort를 권장하는 이유를 조금 더 자세히 알고 싶습니다.이 부분에서 list.sort()를 사용하는 게 더 객체지향적인 코드라고 말씀해주셨는데 List 인터페이스에 정의된 sort() 메서드를 사용하는 게 Collections class 에 정의된 static 메서드보다 어떤 측면에서 더 객체지향적인지 느낌은 오는데 이것 때문이다 라고 정리가 잘 안돼서 질문 드립니다.  Collections 의 코드를 봤을 때 내부에서 Collections.sort(list, comparator)를 보게되면 list.sort(comparator) 메서드를 사용하고 있는데 그러면 굳이 Collections.sort()를 사용해야 할 케이스가 따로 있어서 정의한 것인지 어떤 경우에 사용하는지 궁금합니다. public static <T> void sort(List<T> list, Comparator<? super T> c) { list.sort(c); }

비밀번호가 뭔가요?ㅠ

100만 이하의 약수가 존재하는지 확인할 때 반복문을 왜 101만까지 돌리는 건 가요? 저는 입력 받은 수까지 확인을 했었거든요... 이유가 궁금합니다!백만보다 큰지 안 큰지 확인하기 위함인 건 알겠는데 수학적으로 이해가 좀 안 가서 질문을 드립니다.추가적으로 알고리즘을 풀다보면 수학적인 지식이 좀 많이 부족하다고 느끼는데 어떻게 채우는 게 좋을지도 궁금합니다.. 6개월 정도 회사 다니면서 코테에만 집중해서 이직하는 게 현재 목표입니다. 제가 작성한 답안입니다.답 도출까지는 못했습니다.

메모리 풀링은 그렇다면 주로 어느정도의 사이즈를 가정할 수 있을때나 시스템상 핸들링 할 수 있는 최대치를 넣어 구현한다는 말씀이신가요?그렇다면 내부적으로 너무 많은 메모리를 사용하지않고 낭비되어 효율성이 떨어지지 않나요? 어느 시점에 써야 하는지에 대한 부분이 좀 명확하지않아, 어떤 상황에 써야 되는 기법인지 묻고 싶습니다. 2번째는 현 tail 노드를 추가하는 부분에 있어서 .... 왜 마지막 노드의 next가 NULL인것에서 문제가 생기는 지 이해가 잘 되지 않습니다.for문이나 while문으로 loop하여 display하는것으로 가정했을때 마지막 노드 next가 0이게 되면 더이상 반복문이 실행되지않고 끝나게 되면서, NULL이 프린트 되지않고 나오지않나요?예시로 for문 중간에 왜 아무것도 기입하지 않는 부분도 어떻게 컴파일은 진행이되고 세크먼트로폴트 결과가 나오는걸까요? 혹시 선생님 말씀은 null로 마지막 node가 설정되지 않은 쓰레기값이 설정되었을때를 방지하기위해 tail노드를 추가적으로 안전하게 설치하자는 말씀이실까요?

class Node { constructor(value) { this.value = value; this.left = null; this.right = null; } } class BinarySearchTree { constructor() { this.root = null; // 숙제 몇개 인지 확인하는 count this.length = 0; } #insert(node, value) { if (node.value > value) { // 루트노드보다 작은 값이면 if (node.left) { this.#insert(node.left, value); } else { node.left = new Node(value); } } else { // 숙제 : 같은 값을 넣은경우 에러 처리 (alert, throw) if (node.value === value) throw new Error(`이미 해당 ${value}가 존재 합니다`); // 루트노드보다 큰 값이면 if (node.right) { this.#insert(node.right, value); } else { node.right = new Node(value); } } } insert(value) { if (!this.root) { this.root = new Node(value); } else { this.#insert(this.root, value); } this.length++; } #search(node, value) { if (!node) return null; if (node.value > value) { return this.#search(node.left, value); } else if (node.value === value) { return node; } else { return this.#search(node.right, value); } // if (node.value > value) { // // 더 작은값 찾을때 // if (!node.left) { // return null; // } // if (node.left.value === value) { // return node.left; // } // return this.#search(node.left, value); // } else { // if (!node.right) { // return null; // } // if (node.right.value === value) { // return node.right; // } // return this.#search(node.right, value); // } } search(value) { if (!this.root) return null; if (this.root.value === value) { return this.root; } return this.#search(this.root, value); } #remove(node, value) { if (!node) { // 제거 할 값이 bst에 존재하지 않는 경우 return null; // 지울 값이 존재 안하면 null return } if (node.value === value) { // 자식 입장 // 지울 값을 찾은 경우 if (!node.left && !node.right) { this.length--; // leaf return null; } else if (!node.left) { // 왼팔만 없는 경우 return node.right; // 왼팔이 없는 경우 자기 왼팔 대신 오른팔을 쓰라고 return 해줌 } else if (!node.right) { // 오른팔만 없는 경우 return node.left; // 오른팔 없는 경우 자기 오른팔 대신 왼팔을 쓰라고 return 해줌 } else { // 양팔 다 있는 경우 let exchange = node.left; while (exchange.right) { exchange = exchange.right; } const temp = node.value; node.value = exchange.value; exchange.value = temp; node.left = this.#remove(node.left, exchange.value); return node; } } else { // 부모 입장 if (node.value > value) { node.left = this.#remove(node.left, value); return node; } else { node.right = this.#remove(node.right, value); return node; } } } remove(value) { // 1. leaf(양팔 다 없음) -> 제거 // 2. leaf x, 왼팔이 없다 -> 오른팔 끌어올린다 // 3. leaf x, 오른팔이 없다 -> 왼팔 끌어올린다 // 4. leaf x, 양팔 다 있다 -> 왼팔에서 가장 큰 애와 바꾼다, leaf를 지운다 this.root = this.#remove(this.root, value); // return 숙제 length return 하기 return this.length; } } const bst = new BinarySearchTree(); bst.insert(8); bst.insert(10); bst.insert(3); bst.insert(1); bst.insert(14); bst.insert(6); bst.insert(7); bst.insert(4); bst.insert(13); console.log(bst.length); // 9 console.log(bst.remove(8)); // 8 bst.search(7); bst.search(5); console.log(bst.remove(4)); // 7 console.log(bst.remove(15)); // 없는 값을 지운다면 현재 length return 7 숙제 정답일까요?제발 ㅠㅠ 🙏

[질문 템플릿]1. 강의 내용과 관련된 질문인가요? 예2. 인프런의 질문 게시판과 자주 하는 질문에 없는 내용인가요? 예3. 질문 잘하기 메뉴얼을 읽어보셨나요? 예[질문 내용]지난 강의에서 ArrayList와 LinkedList 구현체 선택 기준이데이터를 조회할 일이 많거나 뒷 부분에 데이터를 추가,삭제가 많은 경우→ 배열 리스트앞쪽의 데이터 추가, 삭제가 많은 경우→ 연결 리스트로 알려주셨습니다. 이번 ArrayDeque와 LinkedList의 구현체 선택 기준에 대한 언급은 없는데, 실무에서 거의 ArrayDeque로만 사용해서 그런건가요? 아니면 실무에서 ArrayDeque 대신 LinkedList로 사용할 때도 ArrayList와 LinkedList의 선택 기준이랑 동일하게 앞쪽에 데이터 추가, 삭제가 많을 때 사용하나요? 강의에서는 덱의 구현체는노드 링크를 사용하는 LinkedList보다는 단순한 배열 구조로 성능이 빠른 ArrayDeque를 사용하자로 마무리하셔서 질문 남깁니다.

class Node { constructor(value) { this.value = value; this.left = null; this.right = null; } } class BinarySearchTree { constructor() { this.root = null; } #insert(node, value) { if (node.value > value) { // 루트노드보다 작은 값이면 if (node.left) { this.#insert(node.left, value); } else { node.left = new Node(value); } } else { // 숙제 : 같은 값을 넣은경우 에러 처리 (alert, throw) if (node.value === value) throw new Error(`이미 해당 ${value}가 존재 합니다`); // 루트노드보다 큰 값이면 if (node.right) { this.#insert(node.right, value); } else { node.right = new Node(value); } } } insert(value) { if (!this.root) { this.root = new Node(value); } else { this.#insert(this.root, value); // 숙제 : 같은 값을 넣은경우 에러 처리 (alert, throw) } } search(value) {} remove(value) {} } const bst = new BinarySearchTree(); bst.insert(8); //bst.insert(8); // Error: 이미 해당 8가 존재 합니다 bst.insert(10); //bst.insert(10); // Error: 이미 해당 10가 존재 합니다 bst.insert(3); //bst.insert(3); // Error: 이미 해당 3가 존재 합니다 bst.insert(1); //bst.insert(1); // Error: 이미 해당 1가 존재 합니다 bst.insert(14); //bst.insert(14); // Error: 이미 해당 14가 존재 합니다 bst.insert(6); //bst.insert(6); // Error: 이미 해당 6가 존재 합니다 bst.insert(7); //bst.insert(7); // Error: 이미 해당 7가 존재 합니다 bst.insert(4); //bst.insert(4); // Error: 이미 해당 4가 존재 합니다 bst.insert(13); //bst.insert(13); // Error: 이미 해당 13가 존재 합니다숙제 코드 정답일까요?

class Node { constructor(value) { this.value = value; this.left = null; this.right = null; } } class BinarySearchTree { constructor() { this.root = null; } #insert(node, value) { if (node.value > value) { // 루트노드보다 작은 값이면 if (node.left) { this.#insert(node.left, value); } else { node.left = new Node(value); } } else { // 루트노드보다 큰 값이면 if (node.right) { this.#insert(node.right, value); } else { node.right = new Node(value); } } } insert(value) { if (!this.root) { this.root = new Node(value); } else { this.#insert(this.root, value); // 숙제 : 같은 값을 넣은경우 에러 처리 (alert, throw) } } search(value) {} remove(value) {} } const bst = new BinarySearchTree(); bst.insert(8); bst.insert(10); bst.insert(3); bst.insert(1); bst.insert(14); bst.insert(6); bst.insert(7); bst.insert(4); bst.insert(13); 영상 따라 했는데 안되면 해당 코드 참고 해보세용!