写一个简单的js选择排序
时间: 2023-07-20 19:28:19 浏览: 33
好的,以下是一个简单的JavaScript选择排序的实现:
```javascript
function selectionSort(arr) {
var len = arr.length;
var minIndex, temp;
for (var i = 0; i < len - 1; i++) {
minIndex = i;
for (var j = i + 1; j < len; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
return arr;
}
```
这个函数接受一个数组作为参数,并对该数组进行选择排序。它首先获取数组的长度,然后遍历数组,每次找到剩余部分中最小的元素并将其与当前元素交换。最后返回排序后的数组。
相关问题
帮我写一个js快速排序
### 回答1:
我可以为你提供一个简单的 JavaScript 快速排序函数:function quickSort(arr) {
if (arr.length <= 1) return arr;
let pivot = arr[arr.length - 1];
let left = [];
let right = [];
for (let i = 0; i < arr.length - 1; i++) {
if (arr[i] < pivot) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
return [...quickSort(left), pivot, ...quickSort(right)];
}
### 回答2:
以下是一个使用 JavaScript 实现的快速排序算法:
```javascript
function quickSort(array) {
if (array.length <= 1) {
return array;
}
const pivotIndex = Math.floor(array.length / 2);
const pivot = array[pivotIndex];
const lesser = [];
const greater = [];
for (let i = 0; i < array.length; i++) {
if (i === pivotIndex) {
continue;
}
if (array[i] < pivot) {
lesser.push(array[i]);
} else {
greater.push(array[i]);
}
}
return [...quickSort(lesser), pivot, ...quickSort(greater)];
}
// 示例使用
const unsortedArray = [9, 5, 1, 8, 2, 7, 3];
const sortedArray = quickSort(unsortedArray);
console.log(sortedArray);
```
上述代码定义了一个 `quickSort` 函数,它接受一个数组作为输入,返回一个排序后的新数组。这个函数使用了递归的方式实现快速排序算法。
快速排序算法的基本思想是选取一个基准元素(`pivot`),将数组中比基准元素小的元素放在一个较小子数组中,比基准元素大的元素放在一个较大子数组中,然后递归地对这两个子数组进行排序。最终,所有子数组都排序完成后,将它们合并成一个有序数组。
在函数内部,我们首先处理一些基本情况:如果数组长度小于等于 1,直接返回该数组,因为长度小于等于 1 的数组已经是有序的。
然后,我们选择基准元素,这里选择数组的中间元素作为基准元素。接着,我们创建两个空数组 `lesser` 和 `greater`,用于存放比基准元素小和大的元素。
接下来的循环中,我们遍历数组,将元素根据与基准元素的大小关系分别放入 `lesser` 或 `greater` 数组中。
最后,我们使用扩展运算符(`...`)将经过递归处理后的 `lesser` 前半部分、基准元素和 `greater` 后半部分的数组连接起来,返回最终排序后的数组。
示例使用了一个无序数组 `[9, 5, 1, 8, 2, 7, 3]`,经过快速排序算法处理后,得到有序数组 `[1, 2, 3, 5, 7, 8, 9]`。
### 回答3:
当然可以帮您写一个js快速排序算法。快速排序是一种高效的排序算法,它基于分治的思想,通过递归将数组分割成较小的子数组,然后将子数组按照特定的规则进行排序。下面是一个简单的js快速排序实现:
```javascript
function quickSort(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));
}
// 示例用法
var unsortedArray = [5, 8, 1, 6, 3, 9, 2, 7, 4];
var sortedArray = quickSort(unsortedArray);
console.log(sortedArray);
```
这个快速排序算法是基于递归实现的。它首先选择一个数作为基准点(pivot),然后将数组分割成两部分:小于基准点的数放在左边,大于基准点的数放在右边。之后,分别对左右两部分数组进行递归排序,最后将排序好的左右两部分数组和基准点连接起来,返回最终的排序结果。
以上是一个简单的实现,实际使用时可能需要考虑性能优化、边界条件等方面的问题。
帮我写一个js的冒泡排序
### 回答1:
好的,下面是一个冒泡排序的JavaScript代码实现:
```
// 定义一个函数用于实现冒泡排序
function bubbleSort(arr) {
// 定义一个变量用于表示是否发生交换的标志
let swapped;
// 循环遍历数组中的每一个元素
for (let i = 0; i < arr.length; i++) {
// 初始化标志变量为 false
swapped = false;
// 内层循环,用于比较相邻的两个元素并交换位置
for (let j = 0; j < arr.length - i - 1; j++) {
// 如果前一个元素比后一个元素大,则交换它们的位置
if (arr[j] > arr[j + 1]) {
// 交换两个元素的位置
let temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
// 设置标志变量为 true,表示发生了交换
swapped = true;
}
}
// 如果标志变量为 false,表示没有发生交换,说明数组已经有序,可以退出循环
if (!swapped) {
break;
}
}
// 返回排序后的数组
return arr;
}
// 测试冒泡排序函数
let arr = [5, 3, 6, 2, 10];
console.log(bubbleSort(arr)); // 输出 [2, 3, 5, 6, 10]
```
在上面的代码中,我们定义了一个 `bubbleSort` 函数用于实现冒泡排序。这个函数接受一个数组作为参数,并返回一个排序后的数组。
在函
### 回答2:
冒泡排序是一种简单但效率相对较低的排序算法。它通过不断交换相邻两个元素的位置,使得当前轮次最大(或最小)的元素逐渐“冒泡”到正确的位置上。以下是一个使用JavaScript实现的冒泡排序的代码:
```javascript
function bubbleSort(arr) {
var len = arr.length;
for (var i = 0; i < len - 1; i++) {
for (var j = 0; j < len - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// 交换位置
var temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}
// 示例用法
var arr = [64, 34, 25, 12, 22, 11, 90];
console.log("排序前:" + arr);
arr = bubbleSort(arr);
console.log("排序后:" + arr);
```
以上代码中,`bubbleSort`函数接受一个数组作为参数,并对其进行冒泡排序,并返回排序后的数组。外层的`for`循环用于控制每一轮交换的次数,内层的`for`循环用于遍历当前轮次未排序的元素,并进行相邻元素的比较与交换。最终,输出排序前与排序后的数组结果。
以上是一个简单的冒泡排序的JS实现,但需要注意的是,冒泡排序的时间复杂度为O(n^2),因此对于大规模数据排序来说并不推荐使用冒泡排序,而是选择更高效的排序算法。
### 回答3:
当然可以,以下是一个简单的JavaScript实现冒泡排序的代码:
```javascript
function bubbleSort(arr) {
var len = arr.length;
for (var i = 0; i < len; i++) {
for (var j = 0; j < len - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
var temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}
var arr = [4, 2, 7, 1, 3];
console.log(bubbleSort(arr)); // 输出 [1, 2, 3, 4, 7]
```
以上代码使用了双重循环,外层循环控制总共进行的轮数,内层循环用于比较并交换相邻元素,将较大的元素逐步冒泡到末尾。在每一轮循环结束后,最大的元素将会冒泡到正确的位置上。最终,数组将按照升序排列。