排序算法

最新推荐文章于 2020-11-22 11:38:33 发布
最新推荐文章于 2020-11-22 11:38:33 发布
阅读量84 收藏
点赞数
文章标签： 数据结构与算法 shell
原文链接：https://juejin.im/post/5c09e703e51d454f7e2b93eb
版权


1.冒泡排序（Bubble Sort）



冒泡排序是一种简单的排序算法。它重复地遍历过要排序的数列，每次比较两个元素，如果它们的顺序不符合预期，就把它们的位置交换过来。遍历数列的工作是重复地进行直到没有再需要交换。因为每遍历数列一次，就有一个元素“浮”到数列的顶端，故此叫做“冒泡排序”。
简要步骤
  1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
  3. 针对所有的元素重复以上的步骤，除了最后一个；
  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
具体实现 
Array.prototype.bubble_sort = function() {
  var i, j, temp
  for (i = 0; i < this.length - 1; i++)
    for (j = 0; j < this.length - 1 - i; j++)
      if (this[j] > this[j + 1]) {
        temp = this[j]
        this[j] = this[j + 1]
        this[j + 1] = temp
      }
  return this
}复制代码
改进冒泡排序：设置一标志性变量 pos,用于记录每趟排序中最后一次进行交换的位置。由于 pos 位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到 pos 位置即可。 
Array.prototype.bubble_sort_improve = function() {
  var i = this.length - 1 //初始时,最后位置保持不变
  while (i > 0) {
    var pos = 0 //每趟开始时,无记录交换
    for (var j = 0; j < i; j++)
      if (this[j] > this[j + 1]) {
        pos = j //记录交换的位置
        var tmp = this[j]
        this[j] = this[j + 1]
        this[j + 1] = tmp
      }
    i = pos //为下一趟排序作准备
  }
  return this
}复制代码
算法分析
  • 最佳情况：T(n) = O(n)
  • 最差情况：T(n) = O(n2)
  • 平均情况：T(n) = O(n2)

2.选择排序（Selection Sort）



是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
简要步骤
  1. 初始状态：无序区为 R[1..n]，有序区为空；
  2. 第 i 趟排序(i=1,2,3...n-1)开始时，当前有序区和无序区分别为 R[1..i-1]和 R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第 1 个记录 R 交换，使 R[1..i]和 R[i+1..n)分别变为记录个数增加 1 个的新有序区和记录个数减少 1 个的新无序区；
  3. n-1 趟结束，数组有序化了。
具体实现 
Array.prototype.selection_sort = function() {
  var i, j, min
  var temp
  for (i = 0; i < this.length - 1; i++) {
    min = i
    for (j = i + 1; j < this.length; j++) if (this[min] > this[j]) min = j
    temp = this[min]
    this[min] = this[i]
    this[i] = temp
  }
}复制代码
算法分析
  • 最佳情况：T(n) = O(n2)
  • 最差情况：T(n) = O(n2)
  • 平均情况：T(n) = O(n2)

3.插入排序（Insertion Sort）



通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用 in-place 排序（即只需用到 {\displaystyle O(1)} {\displaystyle O(1)}的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
简要步骤
  1. 从第一个元素开始，该元素可以认为已经被排序
  2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
  3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
  4. 重复步骤 3，直到找到已排序的元素小于或者等于新元素的位置
  5. 将新元素插入到该位置后
  6. 重复步骤 2~5
具体实现 
Array.prototype.insertion_sort = function() {
  var i, j
  for (i = 1; i < this.length; i++) {
    for (j = 0; j < i; j++) {
      if (this[j] > this[i]) {
        this.splice(j, 0, this[i])
        this.splice(i + 1, 1)
      }
    }
  }
  return this
}复制代码
算法分析
  • 最佳情况：输入数组按升序排列。T(n) = O(n)
  • 最坏情况：输入数组按降序排列。T(n) = O(n2)
  • 平均情况：T(n) = O(n2)

4.希尔排序（Shell Sort）



插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。
简要步骤
  1. 选择一个增量序列 t1，t2，…，tk，其中 ti>tj，tk=1；
  2. 按增量序列个数 k，对序列进行 k 趟排序；
  3. 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
具体实现 
Array.prototype.shell_sort = function() {
  var gap, i, j
  var temp
  for (gap = this.length >> 1; gap > 0; gap >>= 1)
    for (i = gap; i < this.length; i++) {
      temp = this[i]
      for (j = i - gap; j >= 0 && this[j] > temp; j -= gap)
        this[j + gap] = this[j]
      this[j + gap] = temp
    }
}复制代码
算法分析
  • 最佳情况：T(n) = O(nlog2 n)
  • 最坏情况：T(n) = O(nlog2 n)
  • 平均情况：T(n) =O(nlog n)

5.归并排序（Merge Sort）



归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为 2-路归并。
简要步骤
  1. 将序列每相邻两个数字进行归并操作，形成ceil(n/2)个序列，排序后每个序列包含两/一个元素
  2. 若此时序列数不是 1 个则将上述序列再次归并，形成 ceil(n/4)个序列，每个序列包含四/三个元素
  3. 重复步骤 2，直到所有元素排序完毕，即序列数为 1
具体实现 
Array.prototype.merge_sort = function() {
  var merge = function(left, right) {
    var final = []
    while (left.length && right.length)
      final.push(left[0] <= right[0] ? left.shift() : right.shift())
    return final.concat(left.concat(right))
  }
  var len = this.length
  if (len < 2) return this
  var mid = len / 2
  return merge(
    this.slice(0, parseInt(mid)).merge_sort(),
    this.slice(parseInt(mid)).merge_sort()
  )
}复制代码
算法分析
  • 最佳情况：T(n) = O(n)
  • 最差情况：T(n) = O(nlogn)
  • 平均情况：T(n) = O(nlogn)

6.快速排序（Quick Sort）



快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
简要步骤
  1. 从数列中挑出一个元素，称为"基准"（pivot），
  2. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
  3. 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。
具体实现 
Array.prototype.quick_sort = function() {
  var len = this.length
  if (len <= 1) return this.slice(0)
  var left = []
  var right = []
  var mid = [this[0]]
  for (var i = 1; i < len; i++)
    if (this[i] < mid[0]) left.push(this[i])
    else right.push(this[i])
  return left.quick_sort().concat(mid.concat(right.quick_sort()))
}复制代码
算法分析
  • 最佳情况：T(n) = O(nlogn)
  • 最差情况：T(n) = O(n2)
  • 平均情况：T(n) = O(nlogn

7.堆排序（Heap Sort）



堆排序是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
简要步骤
  1. 将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无序区；
  2. 将堆顶元素 R[1]与最后一个元素 R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足 R[1,2...n-1]<=R[n]；
  3. 由于交换后新的堆顶 R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆，然后再次将 R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为 n-1，则整个排序过程完成。
具体实现 
Array.prototype.heap_sort = function() {
  var arr = this.slice(0)
  function swap(i, j) {
    var tmp = arr[i]
    arr[i] = arr[j]
    arr[j] = tmp
  }

  function max_heapify(start, end) {
    //建立父节点指标和子节点指标
    var dad = start
    var son = dad * 2 + 1
    if (son >= end)
      //若子节点指标超过范围直接跳出函數
      return
    if (son + 1 < end && arr[son] < arr[son + 1])
      //先比较两个子节点大小，选择最大的
      son++
    if (arr[dad] <= arr[son]) {
      //如果父节点小于子节点时，交换父子内容再继续子节点和孙节点比较
      swap(dad, son)
      max_heapify(son, end)
    }
  }

  var len = arr.length
  //初始化，i从最后一个父节点开始调整
  for (var i = Math.floor(len / 2) - 1; i >= 0; i--) max_heapify(i, len)
  //先将第一个元素和已排好元素前一位做交换，再重新调整，直到排序完毕
  for (var i = len - 1; i > 0; i--) {
    swap(0, i)
    max_heapify(0, i)
  }

  return arr
}复制代码
算法分析
  • 最佳情况：T(n) = O(nlogn)
  • 最差情况：T(n) = O(nlogn)
  • 平均情况：T(n) = O(nlogn)

8.计数排序（Counting Sort）

计数排序是一种稳定的线性时间排序算法。计数排序使用一个额外的数组 C，其中第 i 个元素是待排序数组 A 中值等于 i 的元素的个数。然后根据数组 C 来将 A 中的元素排到正确的位置。
简要步骤
  1. 找出待排序的数组中最大和最小的元素；
  2. 统计数组中每个值为 i 的元素出现的次数，存入数组 C 的第 i 项；
  3. 对所有的计数累加（从 C 中的第一个元素开始，每一项和前一项相加）；
  4. 反向填充目标数组：将每个元素 i 放在新数组的第 C(i)项，每放一个元素就将 C(i)减去 1。
具体实现 
Array.prototype.counting_sort = function() {
  var len = this.length,
    B = [],
    C = [],
    min = (max = this[0])
  for (var i = 0; i < len; i++) {
    min = min <= this[i] ? min : this[i]
    max = max >= this[i] ? max : this[i]
    C[this[i]] = C[this[i]] ? C[this[i]] + 1 : 1
  }
  for (var j = min; j < max; j++) {
    C[j + 1] = (C[j + 1] || 0) + (C[j] || 0)
  }
  for (var k = len - 1; k >= 0; k--) {
    B[C[this[k]] - 1] = this[k]
    C[this[k]]--
  }
  return B
}复制代码
算法分析
  • 最佳情况：T(n) = O(n+k)
  • 最差情况：T(n) = O(n+k)
  • 平均情况：T(n) = O(n+k)

9.桶排序（Bucket Sort）

桶排序或所谓的箱排序，是一个排序算法，工作的原理是将数组分到有限数量的桶里。每个桶再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。
简要步骤
  1. 设置一个定量的数组当作空桶子。
  2. 寻访序列，并且把项目一个一个放到对应的桶子去。
  3. 对每个不是空的桶子进行排序。
  4. 从不是空的桶子里把项目再放回原来的序列中。
具体实现 
Array.prototype.bucket_sort = function(num) {
  if (this.length <= 1) {
    return this
  }
  var len = this.length,
    buckets = [],
    result = [],
    min = (max = this[0]),
    regex = '/^[1-9]+[0-9]*$/',
    space,
    n = 0
  num = num || (num > 1 && regex.test(num) ? num : 10)
  for (var i = 1; i < len; i++) {
    min = min <= this[i] ? min : this[i]
    max = max >= this[i] ? max : this[i]
  }
  space = (max - min + 1) / num
  for (var j = 0; j < len; j++) {
    var index = Math.floor((this[j] - min) / space)
    if (buckets[index]) {
      //  非空桶，插入排序
      var k = buckets[index].length - 1
      while (k >= 0 && buckets[index][k] > this[j]) {
        buckets[index][k + 1] = buckets[index][k]
        k--
      }
      buckets[index][k + 1] = this[j]
    } else {
      //空桶，初始化
      buckets[index] = []
      buckets[index].push(this[j])
    }
  }
  while (n < num) {
    result = result.concat(buckets[n])
    n++
  }
  return result
}复制代码
算法分析
  • 最佳情况：T(n) = O(n+k)
  • 最差情况：T(n) = O(n+k)
  • 平均情况：T(n) = O(n2)

10.基数排序（Radix Sort）

基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。
简要步骤
  1. 取得数组中的最大数，并取得位数；
  2. arr 为原始数组，从最低位开始取每个位组成 radix 数组；
  3. 对 radix 进行计数排序（利用计数排序适用于小范围数的特点）；
具体实现 
Array.prototype.radix_sort = function(maxDigit) {
  var mod = 10
  var dev = 1
  var counter = []
  console.time('基数排序耗时')
  for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
    for (var j = 0; j < this.length; j++) {
      var bucket = parseInt((this[j] % mod) / dev)
      if (counter[bucket] == null) {
        counter[bucket] = []
      }
      counter[bucket].push(this[j])
    }
    var pos = 0
    for (var j = 0; j < counter.length; j++) {
      var value = null
      if (counter[j] != null) {
        while ((value = counter[j].shift()) != null) {
          this[pos++] = value
        }
      }
    }
  }
  console.timeEnd('基数排序耗时')
  return this
}复制代码
算法分析
  • 最佳情况：T(n) = O(n * k)
  • 最差情况：T(n) = O(n * k)
  • 平均情况：T(n) = O(n * k)
基数排序有两种方法：
MSD 从高位开始进行排序 LSD 从低位开始进行排序
基数排序 vs 计数排序 vs 桶排序 这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：
  • 基数排序：根据键值的每位数字来分配桶
  • 计数排序：每个桶只存储单一键值
  • 桶排序：每个桶存储一定范围的数值


weixin_33800463
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
shell工具之awk
zby2018的博客
03-01 361
shell工具值awk ​ 一个强大的文本分析工具，把文件逐行的读入，以空格为默认的分割符并将每行切片，切开的部分在进行分析处理。 1.基本用法 awk [选项参数] ‘pattern1 {action} pattern2 {action}…’ filename pattern :表示AWK在数据中查找的内容，就是匹配模式 action：在找到匹配内容时所执行的一系列命令。 参数说明 -F...
shell sort 最后一列排序_Linux中Shell的sort排序命令的简单使用
weixin_40002846的博客
11-22 2296
Linux Shell sort排序命令sort将文件的每一行作为一个单位相互比较，比较原则是从首字符向后，依次按ASCII码值进行比较，最后将他们按升序输出。语法：sort [OPTION]... [FILE]...常用参数：-k：指定那一列为排序键-u：在输出行中去除重复行。-b：忽略每行前面开始出的空格字符。-c：检查文件是否已经按照顺序排序。-f：排序时，将小写字母视为大写字母。-i：排序...
shell sort 最后一列排序_Shell 编程 排序工具 sort 和 uniq
weixin_39943442的博客
11-20 378
本篇主要写一些shell脚本排序工具的使用。sort概述sort是一个以行为单位对文件内容进行排序的工具，也可以根据不同的数据类型来排序。用法sort [选项] 参数-f：忽略大小写-b：忽略每行前面的空格-M：按照月份进行排序-n：按照数字进行排序-r：反向排序-u：等同于uniq，表示相同的数据仅显示一行-t：指定分隔符，默认使用Tab键分隔-o ：将排序后的结果转存至指定文件-k：指定排序区...
shell sort 最后一列排序_大白话shell命令系列：数据统计篇(一)
weixin_39549899的博客
11-20 508
1. 说明阅读对象: shell入门小白阅读时间: 5分钟难易程度: 非常容易使用频率: 高频2. 目的从使用场景上，介绍常用shell命令，进行数据统计的用法，仅针对从来没接触过shell命令的小白同学， 熟悉Linux环境的同学，可以跳过这篇文章，直接看中等难度文章: 数据民工来取经儿：大白话shell命令awk：数据统计(二)文章只简单描述数据分析过程中，常用命令使用方式，而不对命令本身做过...
基于比较的排序算法汇总 选择排序法 插入排序法 归并排序法 快速排序法 堆排序法 冒泡排序法 希尔排序法
最新发布
01-15
在IT领域，排序算法是计算机科学中的基础但至关重要的概念，尤其在数据处理和算法设计中扮演着核心角色。本文将深入探讨标题中提到的几种基于比较的排序算法：选择排序、插入排序、归并排序、快速排序、堆排序、冒泡...
C语言排序算法---冒泡排序法
03-23
**冒泡排序法详解** 冒泡排序是一种简单直观的排序算法，它重复地遍历待排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经...
最快的排序算法 最快的内部排序法—桶排序法，排序算法数据结构
04-07
最快的排序算法 最快的内部排序法—桶排序法，排序算法数据结构
常见经典排序算法（C语言）1希尔排序 二分插入法 直接插入法 带哨兵的直接排序法 冒泡排序 选择排序 快速排序 堆排序.docx
05-07
常见的经典排序算法有希尔排序、二分插入法、直接插入法、带哨兵的直接排序法、冒泡排序、选择排序、快速排序、堆排序等。 一、希尔排序（Shell 排序法） 希尔排序法，又称宿小增量排序，是 1959 年由 D.L.Shell ...
最快的排序算法 最快的内部排序法—桶排序法 (1)，排序算法数据结构
04-07
最快的排序算法 最快的内部排序法—桶排序法 (1)，排序算法数据结构
python常用排序算法汇总
02-19
该程序包含7大排序算法: # sort.bubbleSort() #冒泡排序 # sort.shellSort() #希尔排序 # sort.insertionSort() #插入排序 # sort.Selectionsort1() #选择排序 # sort.heapSort() #堆排序 # sort.countSort() ...
java排序算法
09-10
java实现的常用的几种基本排序算法，插入、交换、选择、归并
冒泡排序法+输入输出数组
10-31
上次的改进，审核求过.
十大排序算法
10-16
常见10大算法，从原理，动图解析到代码实现，逐步分析，让你轻松入门算法
排序算法：快速排序
12-22
1.快速排序的思想 先从数列中取出一个数作为基准数（简单起见就选第一个数） 分区过程：将比这个数大的数全放到他的右边，比他小的数全放到他的左边（分治） 再对左右两边的区重复第一步和第二部操作，直到各区间...
各种排序算法的分析及java&python实现
leadai的博客
02-27 378
预计阅读时间20分钟。排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是...
输入十个数进行排序_十大经典排序算法(Javascript描述)
weixin_39899244的博客
11-21 1018
“本文13906字，阅读大约需要35分钟。”这世界上总存在着那么一些看似相似但有完全不同的东西，比如雷锋和雷峰塔，小平和小平头，玛丽和马里奥，Java和Javascript....当年Javascript为了抱Java大腿恬不知耻的让自己变成了Java的干儿子，哦，不是应该是跪舔，毕竟都跟了Java的姓了。可如今，Javascript来了个咸鱼翻身，几乎要统治web领域，Nodejs，R...
shell sort 最后一列排序_SHELL服务器日志分析for SEO
weixin_39902345的博客
11-20 107
无需求，不脚本，下面聊聊SEO中服务器日志分析的重点！从运行环境Linux/（Windows系统可安装cygwin），到SEO应用落地，预估学习成本两小时。Shell命令快速入门：cat：打开文件 grep：内容查找 egrep：支持正则 awk：文本分割 sort：数据排序 uniq：数据去重 head：头部行数 NR：记录行数 wc -l：统计行数SHELL学习方法：第一步跟着...
shell sort 最后一列排序_常见的六种排序方法汇总
weixin_39626089的博客
11-22 576
冒泡排序冒泡排序(英语：Bubble Sort)是⼀种简单的排序算法。它重复地遍历要排序的数列，⼀次⽐较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的⼯作是重复地进⾏直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越⼩的元素会经由交换慢慢“浮”到数列的顶端。冒泡排序算法的运作如下：⽐较相邻的元素。如果第⼀个⽐第⼆个⼤(升序)，就交换他们两个。对每⼀对相邻元素作同样...
html 由大到小排序算法,快速排序法
07-20
快速排序是一种常用的排序算法，可以用来对HTML元素进行由大到小的排序。下面是使用快速排序实现HTML元素的排序算法的示例代码： ```javascript function quickSort(elements) { if (elements.length <= 1) { return elements; } const pivot = elements[0]; const smaller = []; const greater = []; for (let i = 1; i < elements.length; i++) { if (elements[i] > pivot) { smaller.push(elements[i]); } else { greater.push(elements[i]); } } return [...quickSort(smaller), pivot, ...quickSort(greater)]; } // 使用示例 const htmlElements = [5, 2, 8, 1, 9, 3]; const sortedElements = quickSort(htmlElements); console.log(sortedElements); // 输出 [9, 8, 5, 3, 2, 1] ``` 这段代码使用了递归的方式实现快速排序，首先选择一个基准元素（这里选择数组的第一个元素），然后将大于基准元素的元素放入一个数组中，将小于等于基准元素的元素放入另一个数组中。然后对这两个数组分别进行快速排序，并将排序后的结果与基准元素合并起来。 注意：这里的示例代码是对数字进行排序的，如果要对其他类型的HTML元素进行排序，需要根据实际情况进行修改。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值