Algoritma Di Sebalik Kaedah Tatasusunan JavaScript-tutorial js-php.cn

Algorithms Behind JavaScript Array Methods

Algoritma Di Sebalik Kaedah Tatasusunan JavaScript.

Tatasusunan JavaScript datang dengan pelbagai kaedah terbina dalam yang membenarkan manipulasi dan mendapatkan semula data dalam tatasusunan. Berikut ialah senarai kaedah tatasusunan yang diekstrak daripada garis besar anda:

concat()
sertai()
isi()
termasuk()
indexOf()
terbalik()
isih()
sambatan()
di()
copyWithin()
rata()
Array.from()
findLastIndex()
untukSetiap()
setiap()
entri()
nilai()
toReversed() (mencipta salinan terbalik tatasusunan tanpa mengubah suai asal)
toSorted() (membuat salinan disusun tatasusunan tanpa mengubah suai yang asal)
toSpliced() (membuat tatasusunan baharu dengan elemen ditambah atau dialih keluar tanpa mengubah suai yang asal)
dengan() (mengembalikan salinan tatasusunan dengan elemen tertentu diganti)
Array.fromAsync()
Array.of()
peta()
flatMap()
kurangkan()
kurangkan Kanan()
beberapa()
cari()
cariIndex()
findLast()

Biar saya pecahkan algoritma biasa yang digunakan untuk setiap kaedah tatasusunan JavaScript:

1. concat()

Algoritma: Tambah/cantum linear
Kerumitan Masa: O(n) dengan n ialah jumlah panjang semua tatasusunan
Secara dalaman menggunakan lelaran untuk mencipta tatasusunan baharu dan menyalin elemen

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

Salin selepas log masuk

2. sertai()

Algoritma: Lintasan linear dengan penggabungan rentetan
Kerumitan Masa: O(n)
Lelaran melalui elemen tatasusunan dan membina rentetan hasil

// 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;
};

Salin selepas log masuk

3. isi()

Algoritma: Lintasan linear dengan tugasan
Kerumitan Masa: O(n)
Lelaran ringkas dengan penetapan nilai

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

Salin selepas log masuk

4. termasuk()

Algoritma: Carian linear
Kerumitan Masa: O(n)
Imbasan berurutan sehingga elemen ditemui atau tamat dicapai

// 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;
};

Salin selepas log masuk

5. indexOf()

Algoritma: Carian linear
Kerumitan Masa: O(n)
Imbasan berurutan dari mula sehingga perlawanan ditemui

// 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;
};

Salin selepas log masuk

6. terbalik()

Algoritma: Pertukaran dua mata
Kerumitan Masa: O(n/2)
Tukar elemen dari mula/akhir bergerak ke dalam

// 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;
};

Salin selepas log masuk

7. sort()

Algoritma: Biasanya TimSort (hibrid isihan gabungan dan isihan sisipan)
Kerumitan Masa: O(n log n)
Pelayar moden menggunakan algoritma pengisihan adaptif

// 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;
};

Salin selepas log masuk

8. sambung()

Algoritma: Pengubahsuaian tatasusunan linear
Kerumitan Masa: O(n)
Menganjak elemen dan mengubah suai tatasusunan di tempat

// 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;
};

Salin selepas log masuk

9. di()

Algoritma: Akses indeks langsung
Kerumitan Masa: O(1)
Pengindeksan tatasusunan mudah dengan semakan sempadan

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

Salin selepas log masuk

10. copyWithin()

Algoritma: Sekat salinan memori
Kerumitan Masa: O(n)
Salinan memori dalaman dan operasi anjakan

// 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;
};

Salin selepas log masuk

11. rata()

Algoritma: Rekursif depth-first traversal
Kerumitan Masa: O(n) untuk tahap tunggal, O(d*n) untuk kedalaman d
Meratakan tatasusunan bersarang secara rekursif

// 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);
};

Salin selepas log masuk

12. Array.from()

Algoritma: Lelaran dan salin
Kerumitan Masa: O(n)
Mencipta tatasusunan baharu daripada boleh diulang

// 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;
};

Salin selepas log masuk

13. findLastIndex()

Algoritma: Carian linear songsang
Kerumitan Masa: O(n)
Imbasan berurutan dari akhir sehingga perlawanan ditemui

// 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;
};

Salin selepas log masuk

14. forEach()

Algoritma: Lelaran linear
Kerumitan Masa: O(n)
Lelaran ringkas dengan pelaksanaan panggilan balik

// 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);
    }
  }
};

Salin selepas log masuk

15. setiap()

Algoritma: Imbasan linear litar pintas
Kerumitan Masa: O(n)
Berhenti dengan syarat palsu pertama

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

Salin selepas log masuk

16. entri()

Algoritma: Pelaksanaan protokol Iterator
Kerumitan Masa: O(1) untuk penciptaan, O(n) untuk lelaran penuh
Mencipta objek lelaran

// 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;
};

Salin selepas log masuk

17. nilai()

Algoritma: Pelaksanaan protokol Iterator
Kerumitan Masa: O(1) untuk penciptaan, O(n) untuk lelaran penuh
Mencipta lelaran untuk nilai

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

Salin selepas log masuk

18. toReversed()

Algoritma: Salin dengan lelaran terbalik
Kerumitan Masa: O(n)
Mencipta tatasusunan terbalik baharu

// 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;
};

Salin selepas log masuk

19. toSorted()

Algoritma: Salin kemudian TimSort
Kerumitan Masa: O(n log n)
Mencipta salinan yang diisih menggunakan isihan standard

// 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;
};

Salin selepas log masuk

20. toSpliced()

Algoritma: Salin dengan pengubahsuaian
Kerumitan Masa: O(n)
Mencipta salinan diubah suai

// 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;
};

Salin selepas log masuk

21. dengan()

Algoritma: Salinan cetek dengan pengubahsuaian tunggal
Kerumitan Masa: O(n)
Mencipta salinan dengan satu elemen diubah

// 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;
};

Salin selepas log masuk

22. Array.fromAsync()

Algoritma: Lelaran dan pengumpulan tak segerak
Kerumitan Masa: O(n) operasi tak segerak
Mengendalikan janji dan iterabel async

// 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;
};

Salin selepas log masuk

23. Array.of()

Algoritma: Penciptaan tatasusunan langsung
Kerumitan Masa: O(n)
Mencipta tatasusunan daripada hujah

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

Salin selepas log masuk

24. peta()

Algoritma: Lelaran Transform
Kerumitan Masa: O(n)
Mencipta tatasusunan baharu dengan elemen yang diubah

// 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;
};

Salin selepas log masuk

25. flatMap()

Algoritma: Peta rata
Kerumitan Masa: O(n*m) dengan m ialah purata saiz tatasusunan dipetakan
Menggabungkan pemetaan dan merata

// 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);
};

Salin selepas log masuk

26. mengurangkan()

Algoritma: Pengumpulan linear
Kerumitan Masa: O(n)
Pengumpulan berurutan dengan panggilan balik

// 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;
};

Salin selepas log masuk

27. reduceRight()

Algoritma: Pengumpulan linear songsang
Kerumitan Masa: O(n)
Pengumpulan dari kanan ke kiri

// 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;
};

Salin selepas log masuk

28. beberapa()

Algoritma: Imbasan linear litar pintas
Kerumitan Masa: O(n)
Berhenti pada keadaan benar pertama

// 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);
    }
  }
};

Salin selepas log masuk

29. cari()

Algoritma: Carian linear
Kerumitan Masa: O(n)
Imbasan berurutan sehingga syarat dipenuhi

// 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;
};

Salin selepas log masuk

30. findIndex()

Algoritma: Carian linear
Kerumitan Masa: O(n)
Imbasan berurutan untuk keadaan yang sepadan

// 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 };
    }
  };
};

Salin selepas log masuk

31. findLast()

Algoritma: Carian linear songsang
Kerumitan Masa: O(n)
Imbasan berurutan dari hujung

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

Salin selepas log masuk

Saya telah menyediakan pelaksanaan lengkap semua 31 kaedah tatasusunan yang anda minta.

? Berhubung dengan saya di LinkedIn:

Mari kita menyelami dunia kejuruteraan perisian bersama-sama lebih dalam! Saya kerap berkongsi cerapan tentang JavaScript, TypeScript, Node.js, React, Next.js, struktur data, algoritma, pembangunan web dan banyak lagi. Sama ada anda ingin meningkatkan kemahiran anda atau bekerjasama dalam topik yang menarik, saya ingin berhubung dan berkembang dengan anda.

Ikuti saya: Nozibul Islam

Atas ialah kandungan terperinci Algoritma Di Sebalik Kaedah Tatasusunan JavaScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!