JS实现简单排序 ——（冒泡排序、选择排序、插入排序）

在前端笔试与面试中，对数据结构与算法的要求不多，但是排序是必须掌握的，在笔试、面试中经常考到或者提问。在此，我用JS实现了排序中的简单排序——冒泡排序、选择排序、插入排序，并且比较他们的效率。

一、初始化数组

1.创建数组

  function ArrayList () {
  //属性
  this.array = []
  
  //方法
  //将数据插入到数组中的方法
  ArrayList.prototype.insert = function (item) {
    this.array.push(item)
  }

  //toString方法
  ArrayList.prototype.toString = function () {
    return this.array.join('-')
  }

  //交换方法
  ArrayList.prototype.swap = function (a, b) {
    // var temp = this.array[a]
    // this.array[a] = this.array[b]
    // this.array[b] = temp
    //ES6写法：解构
    [ this.array[a], this.array[b] ] = [ this.array[b], this.array[a] ]
  }
  }

2.引入数据

//测试类
var list = new ArrayList()

// 插入元素
list.insert(18)
list.insert(5)
list.insert(15)
list.insert(88)
list.insert(36)
list.insert(9)

//显示
alert(list)

二、冒泡排序

1.冒泡排序的思路

• 对未排序的各元素从头到尾依次比较相邻的两个元素大小关系
• 如果左边的队员高, 则两队员交换位置
• 向右移动一个位置, 比较下面两个队员
• 当走到最右端时, 最高的队员一定被放在了最右边
• 按照这个思路, 从最左端重新开始, 这次走到倒数第二个位置的队员即可.
• 依次类推, 就可以将数据排序完成

2.冒泡排序图解

在线演示：冒泡排序

3.冒泡排序代码

  //冒泡排序
    ArrayList.prototype.bubbleSort = function () {
    //获取数组长度
    var length = this.array.length
    
    //第一次：i=length-1，比较到最后一个位置
    //第二次；i=length-2，比较到倒数第二个位置
    for (var i = length - 1; i >= 0; i--) {
    //第一次：j=0，比较0和1
    //第二次；j=length-2，比较length-2和length-1
      for (var j = 0; j < i; j++) {
        if (this.array[j] > this.array[j+1]) {
          this.swap(j, j+1)
        }
      }
    }

    // 另一种方式
    // for (var i = 0; i < length; i++){
    //   for (var j = 0; j < length - 1 - i; j++) {
    //     if (this.array[j] > this.array[j+1]) {
    //       this.swap(j, j+1)
    //     }
    //   }
    // }
  }

测试冒泡排序

 //测试冒泡排序
 list.bubbleSort()
 alert(list)

4.冒泡排序的效率
大O表示法的规则：

• 用常量1取代运行时间中的所有加法常量
• 在修改后的运行次数函数中, 只保留最高阶项
• 如果最高阶项存在并且不是1, 则去除与这个项相乘的常数.

对于冒泡排序的比较次数：

• 按照上面的6个数字，则要对比5次、4次…1次
• 那么6项数据的对比次数为5+4+3+2+1
• 对于n项数据，为（N-1）+（N-2）… + 1，即为 N*（N-1）/ 2。（首项+末项）*项数 / 2

冒泡排序的比较次数的大O表示：

• N * (N - 1) / 2 =N²/2 - N/2,根据规则2, 只保留最高阶项, 编程n² / 2
• N² / 2, 根据规则3, 去除常量, 得N²
• 因此冒泡排序的大O表示法为O(N²)

冒泡排序的交换次数：

• 如果有两次比较才需要交换一次(不可能每次比较都交换一次.), 那么交换次数为n² / 4
• 由于常量不算在大O表示法中, 因此, 我们可以认为交换次数的大O表示也是O(n²)

三、选择排序

1.选择排序的思路

• 选定第一个索引位置，然后和后面元素依次比较
• 如果后面的队员, 小于第一个索引位置的队员, 则交换位置
• 经过一轮的比较后, 可以确定第一个位置是最小的
• 然后使用同样的方法把剩下的元素逐个比较即可
• 可以看出选择排序，第一轮会选出最小值，第二轮会选出第二小的值，直到最后

2.选择排序图解

在线演示：选择排序

3.选择排序代码

//选择排序
ArrayList.prototype.selectionSort = function () {
  //获取数组长度
  var length = this.array.length

  // 外循环，从0开始，到length-2位置
  for (var i = 0; i < length - 1; i++) {
  // 内循环，从i+1开始，和后面的比较
  var min = i
    for (var j = min + 1; j < length; j++) {
      if (this.array[min] > this.array[j]) {
        min = j
      }
     }
     this.swap(min, i)
    }
   }

测试选择排序

// 测试选择排序
list.selectionSort()
alert(list)

4.选择排序的效率
选择排序的比较次数：

• 选择排序也是比较（N-1）+（N-2）+ … +1
• 因此选择排序和冒泡排序的比较次数都是N*(N-1)/2, 也就是O(N²).

选择排序的交换次数:

• 选择排序的交换次数只有n-1次, 用大O表示法就是O(N).
• 所以选择排序通常认为在执行效率上是高于冒泡排序的.

四、插入排序

1.插入排序的思路

• 局部有序，被标记的元素的前面事已经有序的

• 从第一个元素开始，该元素可以认为已经被排序

• 取出下一个元素，在已经排序的元素序列中从后向前扫描

• 如果该元素（已排序）大于新元素，将该元素移到下一位置

• 重复上一个步骤，直到找到已排序的元素小于或者等于新元素的位置

• 将新元素插入到该位置后, 重复上面的步骤.

2.插入排序图解

在线演示：插入排序

3.插入排序代码

// 插入排序
ArrayList.prototype.insertSort = function () {
// 获取数组长度
var length = this.array.length

// 外层循环：从1这个位置开始获取数据，然后向前面局部有序地插入
for (var i = 1; i < length; i++){
   // 内层循环：获取i位置的元素，和前面的元素进行比较
   var temp = this.array[i]
   var j = i
   while (this.array[j - 1] > temp && j > 0) {
      this.array[j] = this.array[j - 1]
      j--
     }

    // 将j位置的数据，放置temp的值
    this.array[j] = temp
    }
   }

测试插入排序

// 测试插入排序
list.insertSort()
alert(list)

4.插入排序的效率
插入排序的比较次数 ：

• 第一趟时, 需要的最多次数是1, 第二趟最多次数是2, 依次类推, 最后一趟是N-1次.
• 因此是1 + 2 + 3 + … + N - 1 = N * (N - 1) / 2.
• 然而每趟发现插入点之前, 平均只有全体数据项的一半需要进行比较，我们可以除以2得到 N * (N - 1) / 4。相对于选择排序, 其他比较次数是少了一半的.

插入排序的复制次数：

• 跟比较次数一样，最多复制数也是1 + 2 + 3 + … + N - 1 = N * (N - 1) / 2.

对于有序的情况

• 对于已经有序或基本有序的数据来说, 插入排序要好很多。并且对于已经完全有序的列表，插入排序的效率比快速排序更高

• 当数据有序的时候, while循环的条件总是为假, 所以它变成了外层循环中的一个简单语句, 执行N-1次.

• 在这种情况下, 算法运行至需要N(N)的时间, 效率相对来说会更高.

• 插入排序算法的效率高于选择排序。