JavaScript中swap怎么用

在JavaScript中，可以使用一个临时变量来实现两个变量的交换。具体代码如下：

var a = 3;
var b = 5;
var temp;

temp = a;
a = b;
b = temp;

console.log(a);  // 输出 5
console.log(b);  // 输出 3

这样就可以实现变量a和b的交换了。

相关问题

排序算法javascript

JavaScript中常用的排序算法有快速排序、选择排序和堆排序。其中快速排序的平均复杂度为n(log n)，选择排序和堆排序的平均复杂度为n^2。下面是三种排序算法的JavaScript代码实现：

快速排序：

var quickSort = function(arr) {
if (arr.length <= 1) {
return arr;
}
var pivotIndex = Math.floor(arr.length / 2);
var pivot = arr.splice(pivotIndex, 1);
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));
};

选择排序：

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!';
}
}

堆排序：

function heapSort(arr) {
var len = arr.length;

function buildHeap(arr) {
for (var i = Math.floor(len / 2); i >= 0; i--) {
heapify(arr, i);
}
}

function heapify(arr, i) {
var left = 2 * i + 1,
right = 2 * i + 2,
largest = i;
if (left < len && arr[left] > arr[largest]) {
largest = left;
}
if (right < len && arr[right] > arr[largest]) {
largest = right;
}
if (largest !== i) {
swap(arr, i, largest);
heapify(arr, largest);
}
}

function swap(arr, i, j) {
var temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}

buildHeap(arr);
for (var i = len - 1; i > 0; i--) {
swap(arr, 0, i);
len--;
heapify(arr, 0);
}
return arr;
}

快速排序JavaScript

快速排序是一种常用的排序算法，它由C. A. R. Hoare在1960年提出。该算法的时间复杂度为O(nlogn)，但在大多数情况下，快速排序的效率更高，因此得到了广泛的应用。

快速排序的工作原理如下：
1. 选择一个基准元素（通常选择第一个元素）。
2. 将数组分成两部分，一部分包含所有小于基准元素的数，另一部分包含所有大于基准元素的数。
3. 递归地对这两部分进行快速排序。

具体的JavaScript实现可以参考以下代码：

var swap = (arr, i, j) => {
    let temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

var partition = (arr, low, high) => {
    let pivot = arr[low];
    let i = low;
    let j = high + 1;

    while (true) {
        while (arr[++i] < pivot) {
            if (i === high) break;
        }
        while (arr[--j] > pivot) {
            if (j === low) break;
        }
        if (i >= j) break;
        swap(arr, i, j);
    }
    swap(arr, low, j);
    return j;
}

var quickSort = (arr, low, high) => {
    if (low < high) {
        let pivotIndex = partition(arr, low, high);
        quickSort(arr, low, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, high);
    }
    return arr;
}

var sortArray = (arr) => {
    return quickSort(arr, 0, arr.length - 1);
}