JavaScript 实现排序算法（冒泡、选择、插入）、查找算法（顺序、二分）

排序算法

冒泡排序

数组元素依次进行两两比较，若两个元素存在大小关系就进行交换，直到数组有序

冒泡排序的过程，就是从第一个元素开始，重复比较相邻的两个项，若第一项比第二项更大，则交换两者的位置；反之不动。

每一轮操作，都会将这一轮中最大的元素放置到数组的末尾。假如数组的长度是 n，那么当我们重复完 n 轮的时候，整个数组就有序了。

//冒泡排序
var arr=[10,7,5,31,98,27]
console.log(arr)
//升序
for(var i=0;i<arr.length;i++){ //控制排序趟数
    for(var j=0;j<arr.length-1;j++){ //控制比较次数
        if (arr[j]>arr[j+1]) {
            var temp=arr[j]
            arr[j]=arr[j+1]
            arr[j+1]=temp
        }
    }
}

//内循环和外循环可以减少比较次数，但结果不变  简化时间复杂度
var arr=[10,7,5,31,98,27]
for(var i=0;i<arr.length-1;i++){ 
    for(var j=0;j<arr.length-1-i;j++){ 
            var temp=arr[j]
            arr[j]=arr[j+1]
            arr[j+1]=temp
        }
    }
}

//二维数组冒泡排序
//降序
var arr=[
    [1,2,3],
    [4,5,6],
    [7,8,9]
]
for(var i=0;i<arr.length;i++){
    for(var j=0;j<arr[i].length;j++){//控制排序趟数
        for(var k=0;k<arr[i].length-1;k++){//控制比较次数
            if (arr[i][k]<arr[i][k+1]) {                
                var temp=arr[i][k]
                arr[i][k]=arr[i][k+1]
                arr[i][k+1]=temp
            }
        }
    }
}

选择排序

每次从当前无序序列中找最小（大）数，记住其下标，让最小（大）数与当前无序序列的第一个数进行交换，依次循环直到有序

选择排序的关键字是：最小值：循环遍历数组，每次都找出当前范围内的最小值，把它放在当前范围的头部；然后缩小排序范围，继续重复以上操作，直至数组完全有序为止。

//选择排序
var arr=[10,7,5,31,98,27]
console.log(arr)
//升序
for(var i=0;i<arr.length;i++){ //控制比较趟数
    var k=i;//标记 最小数的下标
    var min=arr[k] //假定第一个为最小数
    for(var j=i+1;j<arr.length;j++){ //找序列中最小的数，用k标记下标
        if (min>arr[j]) {
            min=arr[j]
            k=j
        }
    }
    if (k!=i) { //交换未排序序列中最小数和未排序序列的第一个元素交换
        var temp=arr[i]
        arr[i]=arr[k]
        arr[k]=temp
    }
}

//二维数组选择排序
//降序
var arr=[
    [1,2,3],
    [4,5,6],
    [7,8,9]
]
for(var i=0;i<arr.length;i++) {
    for(var j=0;j<arr[i].length;j++){
        var k=j
        var max=arr[i][k]
        for(var n=j+1;n<arr[i].length;n++){
            if (max<arr[i][n]) {
                max=arr[i][n]
                k=n
            }
        }
        if (k!=j) {
            var temp=arr[i][j]
            arr[i][j]=arr[i][k]
            arr[i][k]=temp
        }
    }
}

插入排序

插入排序的核心思想是：找到元素在它前面那个序列中的正确位置。

具体来说，插入排序所有的操作都基于一个这样的前提：当前元素前面的序列是有序的。基于这个前提，从后往前去寻找当前元素在前面那个序列里的正确位置。

function insertSort(arr) {
  // 缓存数组长度
  const len = arr.length
  // temp 用来保存当前需要插入的元素
  let temp  
  // i用于标识每次被插入的元素的索引
  for(let i = 1;i < len; i++) {
    // j用于帮助 temp 寻找自己应该有的定位
    let j = i
    temp = arr[i]  
    // 判断 j 前面一个元素是否比 temp 大
    while(j > 0 && arr[j-1] > temp) {
      // 如果是，则将 j 前面的一个元素后移一位，为 temp 让出位置
      arr[j] = arr[j-1]   
      j--
    }
    // 循环让位，最后得到的 j 就是 temp 的正确索引
    arr[j] = temp
  }
  return arr
}

查找算法

顺序查找

依次比较每个元素

//顺序查找
var arr=[23,78,12,45,89,90]
var t=prompt("请输入要查找的数：")
for(var i=0;i<arr.length;i++){
    if (t==arr[i]) {
        console.log("找到了 索引是"+i)
        break
    }
}
if (i>=arr.length) {
    console.log("没找到")
}

二分法查找（折半查找）

被查找的序列必须有序

var arr=[27,98,5,31,7,10]
var t=prompt("请输入要查找的数")
//需要先排序
for(var i=0;i<arr.length;i++){ //控制排序趟数
    for(var j=0;j<arr.length-1;j++){ //控制比较次数
        if (arr[j]>arr[j+1]) {
            var temp=arr[j]
            arr[j]=arr[j+1]
            arr[j+1]=temp
        }
    }
}
console.log("排序后的序列"+arr)
var i=0,j=arr.length-1
t=parseInt(t)
while (i<=j) {
    var mid=parseInt((i+j)/2)
    if (arr[mid]==t) {
        console.log("查找成功,下标是"+mid)
        break
    }
    else if (arr[mid]>t) { //左区间
        j=mid-1
    }else if(arr[mid]<t){ //右区间
        i=mid+1
    }
}
if (i>j) {
    console.log("没有找到"+t)
}