js实现各种常用排序算法

####1.冒泡排序

var bubbleSort = function (arr) {
  var flag = true;
  var len = arr.length;
  for (var i = 0; i < len - 1; i++) {
    flag = true;
    for (var j = 0; j < len - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        var temp = arr[j+1];
        arr[j+1] = arr[j];
        arr[j] = temp;
        flag = false;
      }
    }
    if (flag) {
      break;
    }
  }
};

####2.选择排序

var selectSort = function (arr) {
  var min;
  for (var i = 0; i < arr.length-1; i++) {
    min = i;
    for (var j = i + 1; j < arr.length; j++) {
      if (arr[min] > arr[j]) {
        min = j;
      }
    }
    if (i != min) {
      swap(arr, i, min);
    }
  }
};
function swap(arr, index1, index2) {
  var temp = arr[index1];
  arr[index1] = arr[index2];
  arr[index2] = temp;
};

####3.插入排序

var insertSort = function (arr) {
  var len = arr.length, key;
  for (var i = 1; i < len; i++) {
    var j = i;
    key = arr[j];
    while (--j > -1) {
      if (arr[j] > key) {
        arr[j + 1] = arr[j];
      } else {
        break;
      }
    }
    arr[j + 1] = key;
  }
};

####4.希尔排序

var shellSort = function (arr) {
  var gaps = [5, 3, 1];
  for (var g = 0; g < gaps.length; ++g) {
    for (var i = gaps[g]; i < arr.length; ++i) {
      var temp = arr[i];
      for (var j = i; j >= gaps[g] && arr[j - gaps[g]] > temp; j -= gaps[g]) {
        arr[j] = arr[j - gaps[g]];
      }
      arr[j] = temp;
    }
  }
};

####5.归并排序

function mergeSort(arr) {
  if (arr.length < 2) {
    return;
  }
  var step = 1;
  var left, right;
  while (step < arr.length) {
    left = 0;
    right = step;
    while (right + step <= arr.length) {
      mergeArrays(arr, left, left + step, right, right + step);
      left = right + step;
      right = left + step;
    }
    if (right < arr.length) {
      mergeArrays(arr, left, left + step, right, arr.length);
    }
    step *= 2;
  }
}
function mergeArrays(arr, startLeft, stopLeft, startRight, stopRight) {
  var rightArr = new Array(stopRight - startRight + 1);
  var leftArr = new Array(stopLeft - startLeft + 1);
  k = startRight;
  for (var i = 0; i < (rightArr.length - 1); ++i) {
    rightArr[i] = arr[k];
    ++k;
  }
  k = startLeft;
  for (var i = 0; i < (leftArr.length - 1); ++i) {
    leftArr[i] = arr[k];
    ++k;
  }
  rightArr[rightArr.length - 1] = Infinity; // 哨兵值
  leftArr[leftArr.length - 1] = Infinity; // 哨兵值
  var m = 0;
  var n = 0;
  for (var k = startLeft; k < stopRight; ++k) {
    if (leftArr[m] <= rightArr[n]) {
      arr[k] = leftArr[m];
      m++;
    }
    else {
      arr[k] = rightArr[n];
      n++;
    }
  }
}

####6.快速排序

var quickSort = function(arr, left, right) {
  var i, j, t, pivot;
  if (left >= right) {
    return;
  }
  pivot = arr[left];
  i = left;
  j = right;
  while (i != j) {
    while (arr[j] >= pivot && i < j) {
      j--;
    }
    while (arr[i] <= pivot && i < j) {
      i++;
    }
    if (i < j) {
      t = arr[i];
      arr[i] = arr[j];
      arr[j] = t;
    }
  }
  arr[left] = arr[j];
  arr[j] = pivot;
  quickSort(arr, left, i - 1);
  quickSort(arr, i + 1, right);
}

####总结:算法效率比较:

排序方法平均情况最好情况最坏情况
冒泡排序O(n²)O(n)O(n²)
选择排序O(n²)O(n²)O(n²)
插入排序O(n²)O(n)O(n²)
希尔排序O(nlogn)~O(n²)O(n^1.5)O(n²)
归并排序O(nlogn)O(nlogn)O(nlogn)
快速排序O(nlogn)O(nlogn)O(n²)
  • 4
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
### 回答1: 快速排序是一种分治算法,通常用于对数组进行排序。它的基本思想是:选择一个基准元素,通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。 下面是用 JavaScript 实现快速排序的示例代码: ``` function quickSort(arr) { if (arr.length <= 1) { return arr; } const pivotIndex = Math.floor(arr.length / 2); const pivot = arr.splice(pivotIndex, 1)[0]; const left = []; const right = []; for (let 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)); } ``` 在这段代码中,我们首先判断数组的长度是否小于等于 1,如果是,则直接返回数组,否则继续执行排序。接下来,我们计算出数组的中间索引,并使用 `splice` 方法将这个元素从数组中取出,作为基准元素。然后我们遍历数组,将比基准元素小的元素放到左边的数组中,将比基准 ### 回答2: 快速排序是一种常用排序算法,通过分治的思想对数组进行排序。使用JavaScript实现快速排序的步骤如下: 1. 选择一个基准元素(通常选择数组的第一个元素)。 2. 将数组分成两个子数组,小于基准元素的放在左边,大于基准元素的放在右边。 3. 对左右子数组分别进行递归调用快速排序。 4. 合并左右子数组和基准元素,得到排序后的数组。 下面是使用JavaScript实现快速排序的代码: ```javascript function quickSort(arr) { // 结束条件:当数组的长度小于等于1时,无需再进行排序 if (arr.length <= 1) { return arr; } // 选择一个基准元素 const pivot = arr[0]; const left = []; const right = []; // 将数组按照基准元素分成左右两个子数组 for (let i = 1; i < arr.length; i++) { if (arr[i] < pivot) { left.push(arr[i]); } else { right.push(arr[i]); } } // 对左右子数组进行递归调用快速排序,并合并左子数组、基准元素和右子数组 return quickSort(left).concat(pivot, quickSort(right)); } // 测试代码 const arr = [5, 2, 7, 3, 9, 1]; const sortedArr = quickSort(arr); console.log(sortedArr); ``` 这段代码实现了快速排序算法,首先选择数组的第一个元素作为基准元素,然后将数组按照基准元素的大小分成左右两个子数组,再对左右子数组进行递归调用快速排序,最后合并左子数组、基准元素和右子数组,返回排序后的数组。 ### 回答3: 快速排序是一种常用排序算法,其基本思想是通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分记录的关键字小,然后再对这两部分记录进行排序,最终得到有序序列。 通过JavaScript实现快速排序算法的关键步骤如下: 1. 确定基准值:选取数组中任意一个元素作为基准值,通常选择第一个元素或最后一个元素。此处以选择第一个元素为例。 2. 分割数组:遍历数组,将小于基准值的元素放在左边,大于基准值的元素放在右边,相等的元素可以放在任意一边。 3. 递归排序:将左边和右边的子数组分别进行快速排序,直到每个子数组只含有一个元素。 4. 合并数组:将排好序的左边数组、基准值和排好序的右边数组依次合并起来,即得到最终的排序结果。 下面是一个使用JavaScript实现快速排序算法的示例代码: ```javascript function quickSort(arr) { if (arr.length <= 1) { return arr; } const pivotIndex = Math.floor(arr.length / 2); const pivot = arr.splice(pivotIndex, 1)[0]; const left = []; const right = []; for (let 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)); } const array = [5, 3, 1, 2, 4]; const sortedArray = quickSort(array); console.log(sortedArray); // [1, 2, 3, 4, 5] ``` 以上是一个简单的使用JavaScript实现快速排序算法的示例,通过递归调用实现对子数组的排序,最终得到整个数组的排序结果。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值