Temu bual bertulis selalunya melibatkan pelbagai algoritma Artikel ini memperkenalkan secara ringkas beberapa algoritma yang biasa digunakan dan melaksanakannya dengan JavaScript.
1. Isih Sisipan
1) Pengenalan Algoritma
Penerangan algoritma bagi Isih-Sisipan ialah A yang mudah dan algoritma pengisihan intuitif. Ia berfungsi dengan membina urutan tersusun Untuk data yang tidak diisih, ia mengimbas dari belakang ke hadapan dalam urutan yang diisih untuk mencari kedudukan yang sepadan dan memasukkannya. Dalam pelaksanaan isihan sisipan, pengisihan di tempat biasanya digunakan (iaitu, pengisihan yang hanya menggunakan ruang tambahan O(1) Oleh itu, semasa proses pengimbasan dari belakang ke hadapan, ia perlu berulang kali dan beransur-ansur beralih mengisih elemen ke belakang , menyediakan ruang sisipan untuk elemen terkini.
2) Penerangan dan pelaksanaan algoritma
Secara umumnya, isihan sisipan dilaksanakan pada tatasusunan menggunakan di tempat. Algoritma khusus diterangkan seperti berikut:
Bermula dari elemen pertama, elemen boleh dianggap telah diisih
Keluarkan elemen seterusnya dan imbas dari belakang ke hadapan dalam urutan elemen yang disusun;
Jika elemen (diisih) lebih besar daripada elemen baharu, alihkan elemen ke kedudukan seterusnya
Ulang langkah 3 sehingga anda menemui kedudukan di mana elemen yang diisih kurang daripada atau sama dengan elemen baharu; 🎜> Masukkan elemen baru ke dalam kedudukan Selepas
Ulang langkah 2~5.
Pelaksanaan kod JavaScript:
function insertionSort(array) {
if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {
for (var i = 1; i < array.length; i++) {
var key = array[i];
var j = i - 1;
while (j >= 0 && array[j] > key) {
array[j + 1] = array[j];
j--;
}
array[j + 1] = key;
}
return array;
} else {
return 'array is not an Array!';
}
}3) Analisis algoritma
Kes terbaik: tatasusunan input Isih dalam susunan menaik. T(n) = O(n) Kes terburuk: tatasusunan input diisih mengikut tertib menurun. T(n) = O(n2)
Purata kes: T(n) = O(n2)
2. Isih sisipan binari
1) Algoritma Pengenalan
Binary-insert-sort ialah algoritma pengisihan yang membuat perubahan kecil pada algoritma pengisihan sisipan langsung. Perbezaan terbesar daripada algoritma isihan sisipan langsung ialah ia menggunakan kaedah carian binari untuk mencari kedudukan sisipan, yang mempunyai peningkatan tertentu dalam kelajuan.2) Penerangan dan pelaksanaan algoritma
Secara umumnya, isihan sisipan dilaksanakan pada tatasusunan menggunakan di tempat. Algoritma khusus diterangkan seperti berikut: Bermula dari elemen pertama, elemen ini boleh dianggap telah diisih Keluarkan elemen seterusnya, dan carian binari untuk mencari yang pertama yang lebih besar daripadanya dalam urutan elemen yang diisih Kedudukan nombor;
Pelaksanaan kod JavaScript:
function binaryInsertionSort(array) {
if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {
for (var i = 1; i < array.length; i++) {
var key = array[i], left = 0, right = i - 1;
while (left <= right) {
var middle = parseInt((left + right) / 2);
if (key < array[middle]) {
right = middle - 1;
} else {
left = middle + 1;
}
}
for (var j = i - 1; j >= left; j--) {
array[j + 1] = array[j];
}
array[left] = key;
}
return array;
} else {
return 'array is not an Array!';
}
}3) Analisis algoritma
Kes terbaik: T( n ) = O(nlogn)Kes terburuk: T(n) = O(n2)
Purata kes: T(n) = O(n2)
3. Isih pilihan
1) Pengenalan algoritma
Isih-pilihan ialah algoritma pengisihan yang mudah dan intuitif. Cara ia berfungsi: Mula-mula, cari elemen terkecil (besar) dalam jujukan yang tidak diisih dan simpannya pada kedudukan permulaan jujukan yang diisih Kemudian, teruskan mencari elemen terkecil (besar) daripada unsur yang tidak diisih yang tinggal, dan kemudian letakkannya ke dalam urutan yang diisih. Dan seterusnya sehingga semua elemen disusun.
2) Penerangan dan pelaksanaan algoritma
Pengisihan pemilihan terus bagi n rekod boleh memperoleh keputusan tersusun melalui pas pengisihan pemilihan langsung n-1. Algoritma khusus diterangkan seperti berikut:
Keadaan awal: kawasan tidak tertib ialah R[1..n], kawasan tertib kosong; ...n- 1) Pada permulaannya, kawasan tertib semasa dan kawasan tak tertib masing-masing ialah R[1..i-1] dan R(i..n). Operasi pengisihan ini memilih rekod R[k] dengan kunci terkecil daripada kawasan bercelaru semasa, dan menukarnya dengan rekod pertama R dalam kawasan bercelaru, supaya R[1..i] dan R[i+1 . n) masing-masing menjadi kawasan tertib baharu dengan bilangan rekod meningkat sebanyak 1 dan kawasan tidak tersusun baharu dengan bilangan rekod berkurangan sebanyak 1n-1 pas selesai dan tatasusunan telah dipesan.
Pelaksanaan kod JavaScript:
function selectionSort(array) {
if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {
var len = array.length, temp;
for (var i = 0; i < len - 1; i++) {
var min = array[i];
for (var j = i + 1; j < len; j++) {
if (array[j] < min) {
temp = min;
min = array[j];
array[j] = temp;
}
}
array[i] = min;
}
return array;
} else {
return 'array is not an Array!';
}
}Kes terbaik: T( n ) = O(n2)Kes terburuk: T(n) = O(n2)Purata kes: T(n) = O(n2)
4. Isih buih
1) Pengenalan algoritma
Isih buih ialah algoritma isihan mudah. Ia berulang kali berjalan melalui urutan untuk diisih, membandingkan elemen dua pada satu masa dan menukarnya jika ia berada dalam susunan yang salah. Kerja melawat tatasusunan diulang sehingga tiada lagi pertukaran diperlukan, yang bermaksud tatasusunan telah diisih. Nama algoritma ini berasal dari fakta bahawa unsur-unsur yang lebih kecil perlahan-lahan akan "terapung" ke bahagian atas tatasusunan melalui pertukaran.
2) Penerangan dan pelaksanaan algoritmaAlgoritma khusus diterangkan seperti berikut: Bandingkan elemen bersebelahan. Jika yang pertama lebih besar daripada yang kedua, tukar kedua-duanya
Lakukan perkara yang sama untuk setiap pasangan elemen bersebelahan, dari pasangan pertama di awal hingga pasangan terakhir di penghujung, supaya elemen di penghujung sepatutnya adalah nombor terbesar;Ulang langkah di atas untuk semua elemen kecuali yang terakhir
Ulang langkah 1~3 sehingga pengisihan selesai.Pelaksanaan kod JavaScript:
function bubbleSort(array) {
if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {
var len = array.length, temp;
for (var i = 0; i < len - 1; i++) {
for (var j = len - 1; j >= i; j--) {
if (array[j] < array[j - 1]) {
temp = array[j];
array[j] = array[j - 1];
array[j - 1] = temp;
}
}
}
return array;
} else {
return 'array is not an Array!';
}
}Kes terbaik: T( n ) = O(n)Kes terburuk: T(n) = O(n2)Purata kes: T(n) = O(n2)
5 🎜> 快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。 2）算法描述和实现 快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下： 从数列中挑出一个元素，称为 "基准"（pivot）； 3）算法分析 最佳情况：T(n) = O(nlogn) 1）算法简介 堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。 2）算法描述和实现 具体算法描述如下： 将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无序区； 3）算法分析 最佳情况：T(n) = O(nlogn) 1）算法简介 归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。 2）算法描述和实现 具体算法描述如下： 把长度为n的输入序列分成两个长度为n/2的子序列； 3）算法分析 最佳情况：T(n) = O(n) 1）算法简介 桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。 2）算法描述和实现 具体算法描述如下： 设置一个定量的数组当作空桶； 3）算法分析 桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。 九、计数排序 1）算法简介 计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。 2）算法描述和实现 具体算法描述如下： 找出待排序的数组中最大和最小的元素； 3）算法分析 当输入的元素是n 个0到k之间的整数时，它的运行时间是 O(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。 以上就是JavaScript实现多种排序算法_javascript技巧的内容，更多相关内容请关注PHP中文网（www.php.cn）！
1) Pengenalan kepada algoritma
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
JavaScript代码实现：
//方法一
function quickSort(array, left, right) {
if (Object.prototype.toString.call(array).slice(8, -1) === 'Array' && typeof left === 'number'
&& typeof right === 'number') {
if (left < right) {
var x = array[right], i = left - 1, temp;
for (var j = left; j <= right; j++) {
if (array[j] <= x) {
i++;
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
quickSort(array, left, i - 1);
quickSort(array, i + 1, right);
};
} else {
return 'array is not an Array or left or right is not a number!';
}
}
var aaa = [3, 5, 2, 9, 1];
quickSort(aaa, 0, aaa.length - 1);
console.log(aaa);
//方法二
var quickSort = function(arr) {
if (arr.length <= 1) { return arr; }
var pivotIndex = Math.floor(arr.length / 2);
var pivot = arr.splice(pivotIndex, 1)[0];
var left = [];
var right = [];
for (var i = 0; i < arr.length; i++){
if (arr[i] < pivot) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
return quickSort(left).concat([pivot], quickSort(right));
};
最差情况：T(n) = O(n2)
平均情况：T(n) = O(nlogn)
六、堆排序
将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n]；
由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
JavaScript代码实现：
/*方法说明：堆排序
@param array 待排序数组*/
function heapSort(array) {
if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {
//建堆
var heapSize = array.length, temp;
for (var i = Math.floor(heapSize / 2); i >= 0; i--) {
heapify(array, i, heapSize);
}
//堆排序
for (var j = heapSize - 1; j >= 1; j--) {
temp = array[0];
array[0] = array[j];
array[j] = temp;
heapify(array, 0, --heapSize);
}
} else {
return 'array is not an Array!';
}
}
/*方法说明：维护堆的性质
@param arr 数组
@param x 数组下标
@param len 堆大小*/
function heapify(arr, x, len) {
if (Object.prototype.toString.call(arr).slice(8, -1) === 'Array' && typeof x === 'number') {
var l = 2 * x, r = 2 * x + 1, largest = x, temp;
if (l < len && arr[l] > arr[largest]) {
largest = l;
}
if (r < len && arr[r] > arr[largest]) {
largest = r;
}
if (largest != x) {
temp = arr[x];
arr[x] = arr[largest];
arr[largest] = temp;
heapify(arr, largest, len);
}
} else {
return 'arr is not an Array or x is not a number!';
}
}
最差情况：T(n) = O(nlogn)
平均情况：T(n) = O(nlogn)
七、归并排序
对这两个子序列分别采用归并排序；
将两个排序好的子序列合并成一个最终的排序序列。
JavaScript代码实现：
function mergeSort(array, p, r) {
if (p < r) {
var q = Math.floor((p + r) / 2);
mergeSort(array, p, q);
mergeSort(array, q + 1, r);
merge(array, p, q, r);
}
}
function merge(array, p, q, r) {
var n1 = q - p + 1, n2 = r - q, left = [], right = [], m = n = 0;
for (var i = 0; i < n1; i++) {
left[i] = array[p + i];
}
for (var j = 0; j < n2; j++) {
right[j] = array[q + 1 + j];
}
left[n1] = right[n2] = Number.MAX_VALUE;
for (var k = p; k <= r; k++) {
if (left[m] <= right[n]) {
array[k] = left[m];
m++;
} else {
array[k] = right[n];
n++;
}
}
}
最差情况：T(n) = O(nlogn)
平均情况：T(n) = O(nlogn)
八、桶排序
遍历输入数据，并且把数据一个一个放到对应的桶里去；
对每个不是空的桶进行排序；
从不是空的桶里把排好序的数据拼接起来。
JavaScript代码实现：
/*方法说明：桶排序
@param array 数组
@param num 桶的数量*/
function bucketSort(array, num) {
if (array.length 1 && regex.test(num)) ? num : 10);
for (var i = 1; i < len; i++) {
min = min = array[i] ? max : array[i];
}
space = (max - min + 1) / num;
for (var j = 0; j < len; j++) {
var index = Math.floor((array[j] - min) / space);
if (buckets[index]) {
// 非空桶，插入排序
var k = buckets[index].length - 1;
while (k >= 0 && buckets[index][k] > array[j]) {
buckets[index][k + 1] = buckets[index][k];
k--;
}
buckets[index][k + 1] = array[j];
} else {
//空桶，初始化
buckets[index] = [];
buckets[index].push(array[j]);
}
}
while (n < num) {
result = result.concat(buckets[n]);
n++;
}
return result;
}
统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
JavaScript代码实现：
function countingSort(array) {
var len = array.length, B = [], C = [], min = max = array[0];
for (var i = 0; i < len; i++) {
min = min = array[i] ? max : array[i];
C[array[i]] = C[array[i]] ? C[array[i]] + 1 : 1;
}
for (var j = min; j < max; j++) {
C[j + 1] = (C[j + 1] || 0) + (C[j] || 0);
}
for (var k = len - 1; k >=0; k--) {
B[C[array[k]] - 1] = array[k];
C[array[k]]--;
}
return B;
}
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
