使用js实现排序算法和搜索算法

已于 2023-02-27 17:43:10 修改
阅读量139 收藏
点赞数 1
文章标签： 算法 javascript
于 2021-10-01 17:04:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42349528/article/details/120536344
版权

排序算法和搜索算法

1. 排序算法

1.1 冒泡排序

let arr = [29,10,12,37,14,20,17,8,9,33,5];
let array = [11,1,2,3,4,5,6,7,8,9,10];
let arr1 = [29,10,12,37,14,20,17,8,9,33,5];
let array1 = [11,1,2,3,4,5,6,7,8,9,10];
//冒泡排序  常规的冒泡排序
function bubbleSort(arr) {
  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]) {
        [arr[j], arr[j+1]] = [arr[j+1], arr[j]]
      }
    }
  }
  return arr;
}
console.log(bubbleSort(arr));
console.log(bubbleSort(array));
//冒泡排序  优化版
function bubbleSortPlus(arr) {
  let flag = arr.length - 1;
  while(flag) {
    let last = 0;
    for(let i = 0; i < flag; i++) {
      if(arr[i] > arr[i+1]){
        [arr[i],arr[i+1]] = [arr[i+1],arr[i]];
        last = i;
      }
    }
    flag = last;
  }
  return arr;
}
console.log(bubbleSortPlus(arr1));
console.log(bubbleSortPlus(array1));

1.2 选择排序

let arr = [29,10,12,37,14,20,17,8,9,33,5];
//选择排序  
function selectionSort(arr){
  for(let i = 0; i < arr.length-1; i++) {
    for(let j = i; j < arr.length-1; j++) {
      if(arr[i] > arr[j+1]){
        [arr[i], arr[j+1]] = [arr[j+1], arr[i]]
      }
    }
  }
  return arr;
}
console.log(selectionSort(arr));

1.3 插入排序

let arr = [29,10,12,37,14,20,17,8,9,33,5];
//插入排序
function insertSort(arr) {
  for(let i = 1; i < arr.length; i++) {  
    let temp = arr[i];  //先把arr[i]赋值给temp
    let j = i;
    while(temp < arr[j-1] && j > 0){  //给arr[i]找插入的位置
      arr[j] = arr[j -1];
      j--;
    }
    arr[j] = temp;  //找到位置了就把a[i]赋值这个位置
  }
  return arr;
}
console.log(insertSort(arr))

1.4 希尔排序

let arr = [29,10,12,37,14,20,17,8,9,33,5];
//希尔排序（缩小增量排序） 是插入排序的改进版
function shellSort(arr) {
  for(var gap = arr.length>>1; gap>0; gap= gap>>1) {
    for(var i=gap; i<arr.length; i++) {
      var j = i;
      var current = arr[i]; // 下面这一段和插入排序思想一样
      while(j-gap >= 0 && current < arr[j-gap]) {
        arr[j] = arr[j - gap];
        j = j - gap;
      }
      arr[j] = current;
    }
  }
  return arr;
}
console.log(shellSort(arr));

1.5 堆排序

let arr = [29,10,12,37,14,20,17,8,9,33,5];
//堆排序
function buildMaxHeap(arr, sub_idx,  size) {
  let left = (sub_idx<<1) + 1, right = (sub_idx<<1) + 2;
  let max_idx = sub_idx;
  if(left<size && arr[left] >= arr[max_idx]) max_idx = left;
  if(right<size && arr[right] >= arr[max_idx]) max_idx = right;
  if(max_idx != sub_idx) {
    [arr[max_idx], arr[sub_idx]] = [arr[sub_idx], arr[max_idx]];
    buildMaxHeap(arr, max_idx, size);
  }
  return;
}
function heapSort(arr) {
  for(let i = (arr.length>>1)-1; i >= 0; i--) {
    buildMaxHeap(arr,i,arr.length);
  }
  for(let i=arr.length-1; i>=0; i--){
    [arr[0], arr[i]] = [arr[i], arr[0]];
    buildMaxHeap(arr,0,i);
  }
  return arr;
}
console.log(heapSort(arr));

1.6 归并排序

let arr = [29,10,12,37,14,20,17,8,9,33,5];
//归并排序
function mergeSort(arr) {
  if(arr.length > 1) {
    const {length} = arr;
    const middle = length>>1;
    const left = mergeSort(arr.slice(0,middle));
    const right = mergeSort(arr.slice(middle,length));
    arr = merge(left,right);
  }
  return arr;
}

function merge(left, right) {
  let i = 0, j = 0;
  const res = [];
  while(i<left.length && j<right.length) {
    res.push(left[i]<right[j] ? left[i++] : right[j++])
  };
  return res.concat(i<left.length ? left.slice(i) : right.slice(j));
}
console.log(mergeSort(arr))

1.7 快速排序

//快速排序
let arr = [29,10,12,37,14,20,17,8,9,33,5];
function quickSort(arr){
    var left = [],right =[];
    if(arr.length <= 1){
        return arr;
    }
    var index = Math.floor(arr.length/2);//取一个基准值，此时取出来的为一个数组
    var p = arr.splice(index,1)[0];//取出数组中的基准值（将基准值从原数组中截取出来）
    for (var i=0;i<arr.length;i++){
        if(arr[i] <= p){
            left.push(arr[i]);
        }else{
            right.push(arr[i]);
        }
    }
    //运用递归
    return quickSort(left).concat(p,quickSort(right));//将左右两边数组连接起来
};
console.log(quickSort(arr));

1.8 计数排序

let arr = [29,10,12,37,14,20,17,8,9,33,5];
//计数排序 必需要求输入的数据是确定范围的整数
function countingSort(arr) {
  let maxValue = arr[0],minValue = arr[0];
  for(let i = 0; i < arr.length; i++) {
    if(arr[i] > maxValue) {
      maxValue = arr[i];
    }
  };
  for(let i = 0; i < arr.length; i++) {
    if(arr[i] < minValue) {
      minValue = arr[i];
    }
  };
  const counts = new Array(maxValue + 1);
  arr.forEach(element => {
    if(!counts[element]) {
      counts[element] = 0;
    }
    counts[element]++;
  });
  let sortedIndex = 0;
  counts.forEach((count, i) => {
    while (count > 0) {
      arr[sortedIndex++] = i;
      count--;
    }
  });
  return arr;
}
console.log(countingSort(arr));

1.9 桶排序

let arr = [29,10,12,37,14,20,17,8,9,33,5];
//桶排序 是计数排序的升级版
function bucketSort(arr) {
  //找到数组中的最大值,最小值
  let minValue = arr[0], maxValue = arr[0];
  for(let i = 1; i < arr.length; i++) {
    if(arr[i] > maxValue){
      maxValue = arr[i];
    } else if(arr[i] < minValue) {
      minValue = arr[i];
    }
  }
  //初始化桶的大小，
  const bucketSize = 5;
  const bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
  const buckets = new Array(bucketSize);
  const res = [];
  for (let i = 0; i < bucketSize; i++) {
    buckets[i] = [];
  }
  for(let i = 0; i < arr.length; i++) {
    buckets[((arr[i] - minValue) / bucketSize) >> 1].push(arr[i])
  }

  for(let i = 0; i < bucketSize; i++) {
    if(buckets[i] !== null) {
      insertSort(buckets[i]);
      for(let j = 0; j < buckets[i].length; j++) {
        res.push(buckets[i][j]);
      }
    }
  }
  return res;
}

function insertSort(arr) {
  for(let i = 1; i < arr.length; i++) {  
    let temp = arr[i];  //先把arr[i]赋值给temp
    let j = i;
    while(temp < arr[j-1] && j > 0){  //给arr[i]找插入的位置
      arr[j] = arr[j -1];
      j--;
    }
    arr[j] = temp;  //找到位置了就把a[i]赋值这个位置
  }
  return arr;
}
console.log(bucketSort(arr))

1.10 基数排序

let arr = [29,10,12,37,14,20,17,8,9,33,5];
// 基数排序
function radixSort(arr) {
  let radixBase = 10;
  let significantDigit = 1;
  let maxValue = Math.max(...arr);

  while(maxValue / significantDigit >= 1) {
    let tempArr = [];
    let buckets = new Array(radixBase);
    for(let i = 0; i < buckets.length; i++) {
      buckets[i] = [];
    };
    for(let i = 0; i < arr.length; i++) {
      buckets[Math.floor(arr[i]/significantDigit) % radixBase].push(arr[i]);  //注意这里的数组是push进去的
    };
    for(let i = 0; i < buckets.length; i++) {
      for(let j = 0; j < buckets[i].length; j++) {
        tempArr.push(buckets[i][j]);
      }
    }
    arr = tempArr;
    significantDigit *= radixBase;
  }
  return arr;
}
console.log(radixSort(arr))

2. 搜索算法

2.1 顺序搜索

let arr = [29,10,12,37,14,20,17,8,9,33,5];
// 线性搜索
const DOES_NOT_EXIST = -1;
function sequentialSearch(arr, value) {
	for(let i = 0; i < arr.length; i++) {
    if(arr[i] == value) {
      return i;  // 返回的是索引值
    }
  }
  return DOES_NOT_EXIST;
}
console.log(sequentialSearch(arr,5))

2.2 二分搜索

let arr = [29,10,12,37,14,20,17,8,9,33,5];
// 二分搜索  需要将数组排序好
const DOES_NOT_EXIST = -1;
function binarySearch(arr,value) {
  const sortedArr = quickSort(arr);
  let left = 0, right = sortedArr.length - 1;
  while(left <= right) {
    let mid = (left + right) >> 1;
    midValue = sortedArr[mid];
    if(midValue > value){
      right = mid -1;
    } else if (midValue < value) {
      left = mid + 1;
    } else {
      return arr.indexOf(midValue);
    }
  }
  return DOES_NOT_EXIST;
}

function quickSort(arr){
    var left = [],right =[];
    if(arr.length <= 1){
        return arr;
    }
    var index = Math.floor(arr.length/2);//取一个基准值，此时取出来的为一个数组
    var p = arr.splice(index,1)[0];//取出数组中的基准值（将基准值从原数组中截取出来）
    for (var i=0;i<arr.length;i++){
        if(arr[i] <= p){
            left.push(arr[i]);
        }else{
            right.push(arr[i]);
        }
    }
    //运用递归
    return quickSort(left).concat(p,quickSort(right));//将左右两边数组连接起来
};
console.log(binarySearch(arr,5))

2.3 内插搜索

let arr = [29,10,12,37,14,20,17,8,9,33,5];
// 二分搜索  需要将数组排序好

function interpolationSearch(arr,value) {
  const DOES_NOT_EXIST = -1;
  const sortedArr = quickSort(arr);
  let left = 0, right = sortedArr.length - 1, delta;
  while(left <= right) {
    delta = (value - sortedArr[left]) / (sortedArr[right] - sortedArr[left]);
    position = left + Math.floor((right - left) * delta);
    if (value < sortedArr[position]) {
      right = position - 1;
    } else if (value > sortedArr[position]) {
      left = position + 1;
    } else {
      return arr.indexOf(sortedArr[position])
    }
  }
  return DOES_NOT_EXIST;
}

function quickSort(arr){
    var left = [],right =[];
    if(arr.length <= 1){
        return arr;
    }
    var index = Math.floor(arr.length/2);//取一个基准值，此时取出来的为一个数组
    var p = arr.splice(index,1)[0];//取出数组中的基准值（将基准值从原数组中截取出来）
    for (var i=0;i<arr.length;i++){
        if(arr[i] <= p){
            left.push(arr[i]);
        }else{
            right.push(arr[i]);
        }
    }
    //运用递归
    return quickSort(left).concat(p,quickSort(right));//将左右两边数组连接起来
};
console.log(interpolationSearch(arr,5))
少吃一口就会少吃一口
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值