JavaScript利用冒泡排序和插入排序将数组[11,58,60,13,79,90]中的元素从大到小排序。

冒泡排序：

let arr = [11, 58, 60, 13, 79, 90];
for (let i = 0; i < arr.length - 1; i++) {
  for (let j = 0; j < arr.length - 1 - i; j++) {
    if (arr[j] < arr[j + 1]) {
      let temp = arr[j];
      arr[j] = arr[j + 1];
      arr[j + 1] = temp;
    }
  }
}
console.log(arr); // [90, 79, 60, 58, 13, 11]

插入排序：

let arr = [11, 58, 60, 13, 79, 90];
for (let i = 1; i < arr.length; i++) {
  let temp = arr[i];
  let j = i - 1;
  while (j >= 0 && arr[j] < temp) {
    arr[j + 1] = arr[j];
    j--;
  }
  arr[j + 1] = temp;
}
console.log(arr); // [90, 79, 60, 58, 13, 11]

相关问题

利用冒泡排序，将数组[11,58,60,13,79,90,88,34,15,75]中的元素按照从大到小的顺序排列。JS

好的，让我来回答您的问题。这里是一个利用冒泡排序，将数组[11,58,60,13,79,90,88,34,15,75]中的元素按从大到小顺序排列的 JavaScript 代码:

let arr = [11, 58, 60, 13, 79, 90, 88, 34, 15, 75];

for (let i = 0; i < arr.length; i++) {
  for (let j = 0; j < arr.length - i - 1; j++) {
    if (arr[j] < arr[j + 1]) {
      let tmp = arr[j];
      arr[j] = arr[j + 1];
      arr[j + 1] = tmp;
    }
  }
}

console.log(arr);

执行以上代码之后，您将得到一个按照从大到小排列的数组[90, 88, 79, 75, 60, 58, 34, 15, 13, 11]。

希望这个回答对您有所帮助。如果您还有其他问题，请随时询问。

利用冒泡排序，将数组[11,58,60,13,79,90,88,34,15,75]中的元素按照从大到小的顺序排列在页面中输出。JS

### 回答1：
当然，我非常乐意为您提供帮助。以下是利用冒泡排序算法将数组[11, 58, 60, 13, 79, 90, 88, 34, 15, 75]从大到小排列的示例JS代码：

var arr = [11, 58, 60, 13, 79, 90, 88, 34, 15, 75];
for (var i = 0; i < arr.length - 1; i++) {
  for (var j = 0; j < arr.length - 1 - i; j++) {
    if (arr[j] < arr[j + 1]) {
      var temp = arr[j];
      arr[j] = arr[j + 1];
      arr[j + 1] = temp;
    }
  }
}
for (var i = 0; i < arr.length; i++) {
  document.write(arr[i] + " ");
}

如果您有任何其他问题或需要进一步的解释，请随时问我。

### 回答2：
利用冒泡排序算法对数组[11,58,60,13,79,90,88,34,15,75]进行从大到小的排序，然后在页面上输出结果。冒泡排序算法的基本思想是重复遍历数组，比较相邻的两个元素，如果前面的元素大于后面的元素，则交换位置，这样每一次遍历都会将最大的元素放到最后。下面是JS代码的具体操作步骤：

1. 声明一个变量array，并将数组[11,58,60,13,79,90,88,34,15,75]赋值给它。

2. 声明一个变量length，并将数组的长度赋值给它。

3. 使用嵌套的for循环进行遍历，外层循环控制遍历的次数，内层循环用于比较相邻的两个元素并进行交换。

4. 在内层循环中，使用if语句比较相邻元素的大小，如果需要交换位置则进行交换。

5. 在内层循环结束后，将最大的元素放到了数组的最后一个位置。

6. 外层循环的次数减1，重复第3到第5步，直到遍历结束。

7. 在页面中输出排列好的数组。

下面是完整的JS代码：

var array = [11,58,60,13,79,90,88,34,15,75];
var length = array.length;

for (var i = length - 1; i >= 0; i--) {
  for (var j = 0; j < i; j++) {
    if (array[j] < array[j + 1]) {
      var temp = array[j];
      array[j] = array[j + 1];
      array[j + 1] = temp;
    }
  }
}

document.write(array);

在页面中运行这段代码后，会输出排列好的数组[90, 88, 79, 75, 60, 58, 34, 15, 13, 11]，即按照从大到小的顺序排列的结果。

### 回答3：
冒泡排序是一种简单的排序算法，它通过多次交换相邻的元素来将数组中的元素按照顺序进行排列。在这个问题中，我们需要利用冒泡排序将给定的数组[11,58,60,13,79,90,88,34,15,75]按照从大到小的顺序进行排序，并在页面中输出结果。

以下是利用JavaScript实现冒泡排序的代码：

var arr = [11, 58, 60, 13, 79, 90, 88, 34, 15, 75];

for (var i = 0; i < arr.length - 1; i++) {
  for (var j = 0; j < arr.length - 1 - i; j++) {
    if (arr[j] < arr[j + 1]) {
      var temp = arr[j];
      arr[j] = arr[j + 1];
      arr[j + 1] = temp;
    }
  }
}

document.write("按照从大到小的顺序排列的数组为：");
for (var k = 0; k < arr.length; k++) {
  document.write(arr[k] + " ");
}

运行以上代码，页面将输出结果为：90 88 79 75 60 58 34 15 13 11，即将给定的数组按照从大到小的顺序排列输出。