JavaScript 배열 메서드의 알고리즘

JavaScript 배열 방법의 알고리즘.

JavaScript 배열에는 배열의 데이터를 조작하고 검색할 수 있는 다양한 내장 메서드가 함께 제공됩니다. 개요에서 추출된 배열 메소드 목록은 다음과 같습니다.

1. 연결()
2. 가입()
3. 채우기()
4. 포함()
5. indexOf()
6. 역방향()
7. 정렬()
8. 스플라이스()
9. ()에서
10. copyWithin()
11. 플랫()
12. Array.from()
13. 마지막 인덱스()
14. 각각()
15. 모든()
16. 항목()
17. 값()
18. toReversed()(원본을 수정하지 않고 배열의 역방향 복사본 생성)
19. toSorted()(원본을 수정하지 않고 정렬된 배열 복사본 생성)
20. toSpliced()(원본을 수정하지 않고 요소를 추가하거나 제거하여 새 배열 생성)
21. with()(특정 요소가 대체된 배열의 복사본을 반환)
22. Array.fromAsync()
23. Array.of()
24. 지도()
25. 플랫맵()
26. 줄이기()
27. reduceRight()
28. 일부()
29. 찾기()
30. findIndex()
31. 마지막 찾기()

각 JavaScript 배열 방법에 사용되는 일반적인 알고리즘을 분석하겠습니다.

1. 연결()

• 알고리즘: 선형 추가/병합
• 시간 복잡도: O(n) 여기서 n은 모든 배열의 전체 길이입니다
• 내부적으로 반복을 사용하여 새 배열을 만들고 요소를 복사합니다.

// concat()
Array.prototype.myConcat = function(...arrays) {
  const result = [...this];
  for (const arr of arrays) {
    for (const item of arr) {
      result.push(item);
    }
  }
  return result;
};

2. 조인()

• 알고리즘: 문자열 연결을 통한 선형 순회
• 시간 복잡도: O(n)
• 배열 요소를 반복하고 결과 문자열을 작성합니다.

// join()
Array.prototype.myJoin = function(separator = ',') {
  let result = '';
  for (let i = 0; i < this.length; i++) {
    result += this[i];
    if (i < this.length - 1) result += separator;
  }
  return result;
};

3. 채우기()

• 알고리즘: 할당을 통한 선형 순회
• 시간 복잡도: O(n)
• 값 할당을 통한 간단한 반복

// fill()
Array.prototype.myFill = function(value, start = 0, end = this.length) {
  for (let i = start; i < end; i++) {
    this[i] = value;
  }
  return this;
};

4. 포함()

• 알고리즘: 선형 검색
• 시간 복잡도: O(n)
• 요소를 찾거나 끝에 도달할 때까지 순차적 스캔

// includes()
Array.prototype.myIncludes = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i < this.length; i++) {
    if (this[i] === searchElement || (Number.isNaN(this[i]) && Number.isNaN(searchElement))) {
      return true;
    }
  }
  return false;
};

5. 인덱스오브()

• 알고리즘: 선형 검색
• 시간 복잡도: O(n)
• 시작부터 일치하는 항목을 찾을 때까지 순차적 스캔

// indexOf()
Array.prototype.myIndexOf = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i < this.length; i++) {
    if (this[i] === searchElement) return i;
  }
  return -1;
};

6. 역방향()

• 알고리즘: 두 포인터 스왑
• 시간 복잡도: O(n/2)
• 시작/끝에서 안쪽으로 이동하면서 요소를 바꿉니다.

// reverse()
Array.prototype.myReverse = function() {
  let left = 0;
  let right = this.length - 1;

  while (left < right) {
    // Swap elements
    const temp = this[left];
    this[left] = this[right];
    this[right] = temp;
    left++;
    right--;
  }

  return this;
};

7. 정렬()

• 알고리즘: 일반적으로 TimSort(병합 정렬과 삽입 정렬의 하이브리드)
• 시간 복잡도: O(n log n)
• 최신 브라우저는 적응형 정렬 알고리즘을 사용합니다.

// sort()
Array.prototype.mySort = function(compareFn) {
  // Implementation of QuickSort for simplicity
  // Note: Actual JS engines typically use TimSort
  const quickSort = (arr, low, high) => {
    if (low < high) {
      const pi = partition(arr, low, high);
      quickSort(arr, low, pi - 1);
      quickSort(arr, pi + 1, high);
    }
  };

  const partition = (arr, low, high) => {
    const pivot = arr[high];
    let i = low - 1;

    for (let j = low; j < high; j++) {
      const compareResult = compareFn ? compareFn(arr[j], pivot) : String(arr[j]).localeCompare(String(pivot));
      if (compareResult <= 0) {
        i++;
        [arr[i], arr[j]] = [arr[j], arr[i]];
      }
    }
    [arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
    return i + 1;
  };

  quickSort(this, 0, this.length - 1);
  return this;
};

8. 스플라이스()

• 알고리즘: 선형 배열 수정
• 시간 복잡도: O(n)
• 요소를 이동하고 배열을 내부에서 수정합니다.

// splice()
Array.prototype.mySplice = function(start, deleteCount, ...items) {
  const len = this.length;
  const actualStart = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
  const actualDeleteCount = Math.min(Math.max(deleteCount || 0, 0), len - actualStart);

  // Store deleted elements
  const deleted = [];
  for (let i = 0; i < actualDeleteCount; i++) {
    deleted[i] = this[actualStart + i];
  }

  // Shift elements if necessary
  const itemCount = items.length;
  const shiftCount = itemCount - actualDeleteCount;

  if (shiftCount > 0) {
    // Moving elements right
    for (let i = len - 1; i >= actualStart + actualDeleteCount; i--) {
      this[i + shiftCount] = this[i];
    }
  } else if (shiftCount < 0) {
    // Moving elements left
    for (let i = actualStart + actualDeleteCount; i < len; i++) {
      this[i + shiftCount] = this[i];
    }
  }

  // Insert new items
  for (let i = 0; i < itemCount; i++) {
    this[actualStart + i] = items[i];
  }

  this.length = len + shiftCount;
  return deleted;
};

9. 에서()

• 알고리즘: 직접 인덱스 액세스
• 시간 복잡도: O(1)
• 경계 확인을 통한 간단한 배열 인덱싱

// at()
Array.prototype.myAt = function(index) {
  const actualIndex = index >= 0 ? index : this.length + index;
  return this[actualIndex];
};

10. 카피내()

• 알고리즘: 블록 메모리 복사
• 시간 복잡도: O(n)
• 내부 메모리 복사 및 이동 작업

// copyWithin()
Array.prototype.myCopyWithin = function(target, start = 0, end = this.length) {
  const len = this.length;
  let to = target < 0 ? Math.max(len + target, 0) : Math.min(target, len);
  let from = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
  let final = end < 0 ? Math.max(len + end, 0) : Math.min(end, len);
  const count = Math.min(final - from, len - to);

  // Copy to temporary array to handle overlapping
  const temp = new Array(count);
  for (let i = 0; i < count; i++) {
    temp[i] = this[from + i];
  }

  for (let i = 0; i < count; i++) {
    this[to + i] = temp[i];
  }

  return this;
};

11. 플랫()

• 알고리즘: 재귀적 깊이 우선 탐색
• 시간 복잡도: 단일 레벨의 경우 O(n), 깊이 d의 경우 O(d*n)
• 중첩 배열을 재귀적으로 평면화합니다.

// flat()
Array.prototype.myFlat = function(depth = 1) {
  const flatten = (arr, currentDepth) => {
    const result = [];
    for (const item of arr) {
      if (Array.isArray(item) && currentDepth < depth) {
        result.push(...flatten(item, currentDepth + 1));
      } else {
        result.push(item);
      }
    }
    return result;
  };

  return flatten(this, 0);
};

12. 배열.from()

• 알고리즘: 반복 및 복사
• 시간 복잡도: O(n)
• iterable에서 새 배열을 생성합니다.

// Array.from()
Array.myFrom = function(arrayLike, mapFn) {
  const result = [];
  for (let i = 0; i < arrayLike.length; i++) {
    result[i] = mapFn ? mapFn(arrayLike[i], i) : arrayLike[i];
  }
  return result;
};

13. 마지막 인덱스() 찾기

• 알고리즘: 역선형 탐색
• 시간 복잡도: O(n)
• 끝부터 일치하는 항목을 찾을 때까지 순차적 스캔

// findLastIndex()
Array.prototype.myFindLastIndex = function(predicate) {
  for (let i = this.length - 1; i >= 0; i--) {
    if (predicate(this[i], i, this)) return i;
  }
  return -1;
};

14. 각()

• 알고리즘: 선형 반복
• 시간 복잡도: O(n)
• 콜백 실행을 통한 간단한 반복

// forEach()
Array.prototype.myForEach = function(callback) {
  for (let i = 0; i < this.length; i++) {
    if (i in this) {  // Skip holes in sparse arrays
      callback(this[i], i, this);
    }
  }
};

15. 매()

알고리즘: 단락 선형 스캔
시간 복잡도: O(n)
첫 번째 거짓 조건에서 중지

// concat()
Array.prototype.myConcat = function(...arrays) {
  const result = [...this];
  for (const arr of arrays) {
    for (const item of arr) {
      result.push(item);
    }
  }
  return result;
};

16. 항목()

• 알고리즘: 반복자 프로토콜 구현
• 시간 복잡도: 생성의 경우 O(1), 전체 반복의 경우 O(n)
• 반복자 객체 생성

// join()
Array.prototype.myJoin = function(separator = ',') {
  let result = '';
  for (let i = 0; i < this.length; i++) {
    result += this[i];
    if (i < this.length - 1) result += separator;
  }
  return result;
};

17. 가치()

• 알고리즘: 반복자 프로토콜 구현
• 시간 복잡도: 생성의 경우 O(1), 전체 반복의 경우 O(n)
• 값에 대한 반복자를 생성합니다.

// fill()
Array.prototype.myFill = function(value, start = 0, end = this.length) {
  for (let i = start; i < end; i++) {
    this[i] = value;
  }
  return this;
};

18. toReversed()

• 알고리즘: 역반복으로 복사
• 시간 복잡도: O(n)
• 새 역방향 배열 생성

// includes()
Array.prototype.myIncludes = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i < this.length; i++) {
    if (this[i] === searchElement || (Number.isNaN(this[i]) && Number.isNaN(searchElement))) {
      return true;
    }
  }
  return false;
};

19. 정렬()

• 알고리즘: 복사 후 TimSort
• 시간 복잡도: O(n log n)
• 표준 정렬을 사용하여 정렬된 복사본을 만듭니다.

// indexOf()
Array.prototype.myIndexOf = function(searchElement, fromIndex = 0) {
  const startIndex = fromIndex >= 0 ? fromIndex : Math.max(0, this.length + fromIndex);
  for (let i = startIndex; i < this.length; i++) {
    if (this[i] === searchElement) return i;
  }
  return -1;
};

20. 스플라이스()

• 알고리즘: 수정하여 복사
• 시간 복잡도: O(n)
• 수정된 사본 생성

// reverse()
Array.prototype.myReverse = function() {
  let left = 0;
  let right = this.length - 1;

  while (left < right) {
    // Swap elements
    const temp = this[left];
    this[left] = this[right];
    this[right] = temp;
    left++;
    right--;
  }

  return this;
};

21. 와()

• 알고리즘: 단일 수정으로 얕은 복사
• 시간 복잡도: O(n)
• 하나의 요소가 변경된 복사본을 만듭니다.

// sort()
Array.prototype.mySort = function(compareFn) {
  // Implementation of QuickSort for simplicity
  // Note: Actual JS engines typically use TimSort
  const quickSort = (arr, low, high) => {
    if (low < high) {
      const pi = partition(arr, low, high);
      quickSort(arr, low, pi - 1);
      quickSort(arr, pi + 1, high);
    }
  };

  const partition = (arr, low, high) => {
    const pivot = arr[high];
    let i = low - 1;

    for (let j = low; j < high; j++) {
      const compareResult = compareFn ? compareFn(arr[j], pivot) : String(arr[j]).localeCompare(String(pivot));
      if (compareResult <= 0) {
        i++;
        [arr[i], arr[j]] = [arr[j], arr[i]];
      }
    }
    [arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
    return i + 1;
  };

  quickSort(this, 0, this.length - 1);
  return this;
};

22. 배열.fromAsync()

• 알고리즘: 비동기식 반복 및 수집
• 시간 복잡성: O(n) 비동기 작업
• Promise 및 비동기 반복 가능 항목을 처리합니다.

// splice()
Array.prototype.mySplice = function(start, deleteCount, ...items) {
  const len = this.length;
  const actualStart = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
  const actualDeleteCount = Math.min(Math.max(deleteCount || 0, 0), len - actualStart);

  // Store deleted elements
  const deleted = [];
  for (let i = 0; i < actualDeleteCount; i++) {
    deleted[i] = this[actualStart + i];
  }

  // Shift elements if necessary
  const itemCount = items.length;
  const shiftCount = itemCount - actualDeleteCount;

  if (shiftCount > 0) {
    // Moving elements right
    for (let i = len - 1; i >= actualStart + actualDeleteCount; i--) {
      this[i + shiftCount] = this[i];
    }
  } else if (shiftCount < 0) {
    // Moving elements left
    for (let i = actualStart + actualDeleteCount; i < len; i++) {
      this[i + shiftCount] = this[i];
    }
  }

  // Insert new items
  for (let i = 0; i < itemCount; i++) {
    this[actualStart + i] = items[i];
  }

  this.length = len + shiftCount;
  return deleted;
};

23. 배열.의()

• 알고리즘: 직접 배열 생성
• 시간 복잡도: O(n)
• 인수에서 배열을 생성합니다.

// at()
Array.prototype.myAt = function(index) {
  const actualIndex = index >= 0 ? index : this.length + index;
  return this[actualIndex];
};

24. 지도()

• 알고리즘: 변환 반복
• 시간 복잡도: O(n)
• 변환된 요소로 새 배열을 만듭니다.

// copyWithin()
Array.prototype.myCopyWithin = function(target, start = 0, end = this.length) {
  const len = this.length;
  let to = target < 0 ? Math.max(len + target, 0) : Math.min(target, len);
  let from = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
  let final = end < 0 ? Math.max(len + end, 0) : Math.min(end, len);
  const count = Math.min(final - from, len - to);

  // Copy to temporary array to handle overlapping
  const temp = new Array(count);
  for (let i = 0; i < count; i++) {
    temp[i] = this[from + i];
  }

  for (let i = 0; i < count; i++) {
    this[to + i] = temp[i];
  }

  return this;
};

25. 플랫맵()

• 알고리즘: 지도 평면화
• 시간 복잡도: O(n*m) 여기서 m은 평균 매핑된 배열 크기입니다
• 매핑과 평면화 결합

// flat()
Array.prototype.myFlat = function(depth = 1) {
  const flatten = (arr, currentDepth) => {
    const result = [];
    for (const item of arr) {
      if (Array.isArray(item) && currentDepth < depth) {
        result.push(...flatten(item, currentDepth + 1));
      } else {
        result.push(item);
      }
    }
    return result;
  };

  return flatten(this, 0);
};

26. 감소()

• 알고리즘: 선형 누적
• 시간 복잡도: O(n)
• 콜백을 통한 순차적 축적

// Array.from()
Array.myFrom = function(arrayLike, mapFn) {
  const result = [];
  for (let i = 0; i < arrayLike.length; i++) {
    result[i] = mapFn ? mapFn(arrayLike[i], i) : arrayLike[i];
  }
  return result;
};

27. 감소오른쪽()

• 알고리즘: 역선형 누적
• 시간 복잡도: O(n)
• 오른쪽에서 왼쪽으로 누적

// findLastIndex()
Array.prototype.myFindLastIndex = function(predicate) {
  for (let i = this.length - 1; i >= 0; i--) {
    if (predicate(this[i], i, this)) return i;
  }
  return -1;
};

28. 좀()

• 알고리즘: 단락 선형 스캔
• 시간 복잡도: O(n)
• 첫 번째 참 조건에서 중지

// forEach()
Array.prototype.myForEach = function(callback) {
  for (let i = 0; i < this.length; i++) {
    if (i in this) {  // Skip holes in sparse arrays
      callback(this[i], i, this);
    }
  }
};

29. 찾기()

• 알고리즘: 선형 검색
• 시간 복잡도: O(n)
• 조건이 충족될 때까지 순차적 스캔

// every()
Array.prototype.myEvery = function(predicate) {
  for (let i = 0; i < this.length; i++) {
    if (i in this && !predicate(this[i], i, this)) {
      return false;
    }
  }
  return true;
};

30. 찾기인덱스()

• 알고리즘: 선형 검색
• 시간 복잡도: O(n)
• 일치 조건에 대한 순차적 스캔

// entries()
Array.prototype.myEntries = function() {
  let index = 0;
  const array = this;

  return {
    [Symbol.iterator]() {
      return this;
    },
    next() {
      if (index < array.length) {
        return { value: [index, array[index++]], done: false };
      }
      return { done: true };
    }
  };
};

31. 마지막 찾기()

• 알고리즘: 역선형 탐색
• 시간 복잡도: O(n)
• 끝부터 순차적 스캔

// concat()
Array.prototype.myConcat = function(...arrays) {
  const result = [...this];
  for (const arr of arrays) {
    for (const item of arr) {
      result.push(item);
    }
  }
  return result;
};

귀하께서 요청하신 배열 메소드 31개를 모두 완벽하게 구현했습니다.

? LinkedIn에서 나와 연결하세요:

소프트웨어 엔지니어링의 세계로 함께 더 깊이 들어가 보세요! 저는 JavaScript, TypeScript, Node.js, React, Next.js, 데이터 구조, 알고리즘, 웹 개발 등에 대한 통찰력을 정기적으로 공유합니다. 기술을 향상하고 싶거나 흥미로운 주제에 대해 공동작업을 하고 싶다면, 저는 여러분과 소통하고 성장하고 싶습니다.

팔로우: 노지불 이슬람

위 내용은 JavaScript 배열 메서드의 알고리즘의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!