数据结构之排序算法

最新推荐文章于 2022-03-27 17:45:09 发布
最新推荐文章于 2022-03-27 17:45:09 发布
阅读量202 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36968599/article/details/118361718
版权

排序算法

0. 比较函数

const COMPARE = {
  LESS_THAN: '-1',
  EQUALITY: '0',
  BIGGER_THAN: '1'
}

const defaultCompareFn = (a, b) => {
  if (a > b) {
    return COMPARE.BIGGER_THAN;
  }
  else if (a === b) {
    return COMPARE.EQUALITY;
  }
  else {
    return COMPARE.LESS_THAN;
  }
}

1. 冒泡排序

比较所有相邻的两个元素的大小，如果第一个元素大于第二个元素则交换这两个元素的位置。
在这里插入图片描述

const bubbleSort = (array, compareFn = defaultCompareFn) => {
  if (!Array.isArray(array)) return false;

  let len = array.length;
  for (let i = 0; i < len; i++) {
    for (let j = 0; j < len-i-1; j++) {
      if (compareFn(array[j], array[j + 1]) === COMPARE.BIGGER_THAN) {
        [array[j], array[j + 1]] = [array[j + 1], array[j]];
      }
    }
  }
  return array;
}
console.log('bubbleSort:', bubbleSort([5, 6, 2, 4, 5, 7,19, 0, 45, 8]));

2. 选择排序

找出数组中的最小值，放在数组中的第一个位置，找出数组中第二小的值，放在数组中的第二个位置，以此类推…

找出最小值所在的索引，与数组中的第一个元素交换位置，依次类推…
在这里插入图片描述

const selectionSort = (array, compareFn = defaultCompareFn) => {
  if (!Array.isArray(array)) return false;

  const { length: len } = array;
  for (let i = 0; i < len; i++) {
    let minIndex = i;
    for (let j = i; j < len; j++) {
      if (compareFn(array[minIndex], array[j]) === COMPARE.BIGGER_THAN) {
        minIndex = j;
      }
    }
    if (minIndex !== i) {
      [array[i], array[minIndex]] = [array[minIndex], array[i]];
    }
  }
  return array;
}

3. 插入排序

将第二个元素和第一个元素排序、将第三个元素和前两个元素排序、将第四个元素和前三个元素排序，以此类推…
对于小型数组来说这种排序方式效率要比冒泡排序和选择排序效率高。
在这里插入图片描述

const insertionSort = (array, compareFn = defaultCompareFn) => {
  if (!Array.isArray(array)) return false;

  const { length: len } = array;
  for (let i = 1; i < len; i++) {
    let j = i;
    const temp = array[i];
    while (j > 0 && compareFn(array[j - 1], temp) === COMPARE.BIGGER_THAN) {
      array[j] = array[j - 1];
      j--;
    }
    array[j] = temp;
  }
  return array;
}

4. 归并排序

归并排序是第一个可以实际使用的排序方法，前面三种排序方法性能都不好。
采取分而治之的方式，将一个大数组从中间切分成小数组，直到小数组长度为1，然后对被切分的两个小数组进行排序，组成排序后的大数组，依次类推…
在这里插入图片描述

// 小数组排序，返回排序后的大数组
const merge = (left, right, compareFn = defaultCompareFn) => {
  let i = 0;
  let j = 0;
  const result = [];
  while(i < left.length && j < right.length) {
    result.push(
      compareFn(left[i], right[j]) === COMPARE.BIGGER_THAN ?
        right[j++] :
        left[i++]
    )
  }
  return result.concat(i >= left.length ? right.slice(j) : left.slice(i));
}
// 主题函数
const mergeSort = (array, compareFn = defaultCompareFn) => {
  if (!Array.isArray(array)) return [];
  const { length: len } = array;
  if (len > 1) {
    const middle = Math.floor(len / 2);
    const left = mergeSort(array.slice(0, middle), compareFn);
    const right = mergeSort(array.slice(middle, len), compareFn);
    array = merge(left, right, compareFn);
  }
  return array;
}

5. 快速排序

快速排序也是一种分而治之的方式实现的排序方法。

  1. 选取中间值作为主元（pivot)

  2. 划分操作：选取最左边的索引作为左指针，最右边的索引作为右指针。移动左指针知道找到一个比主元大的值，在移动右指针，知道找到一个比主元小的值，然后交换他们， 直到左侧的指针超过右侧的指针，这个过程中是的，左指针前面的值都小于左指针以及左指针后面的值。

  3. 对划分后的两个数组进行上面两个步骤操作，直到数组已经完全排序。

// 主函数
function quickSort(array, compareFn = defaultCompareFn) {
  if (!Array.isArray(array)) return false;

  return quick(array, 0, array.length - 1, compareFn);
}
// 递归函数
function quick(array, left, right, compareFn = defaultCompareFn) {
  if (array.length > 1) {
    const index = partition(array, left, right, compareFn);
    if (left < index - 1) {
      array = quick(array, left, index - 1, compareFn);
    }
    if (index < right) {
      array = quick(array, index, right, compareFn);
    }
  }
  return array;
}
// 划分方法
function partition(array, left, right, compareFn) {
  const pivot = array[Math.floor((left + right) / 2)];
  let i = left;
  let j = right;
  while (i <= j) {
    while (compareFn(array[i], pivot) === COMPARE.LESS_THAN) {
      i++;
    }
    while(compareFn(array[j], pivot) === COMPARE.BIGGER_THAN) {
      j--;
    }
    if (i <= j) {
      [array[i], array[j]] = [array[j], array[i]];
      i++;
      j--;
    }
  }
  return i;
}

6. 计数算法

这是一个分布式排序算法，对于整数来说是一种优秀算法。

使用一个临时数组来储存原始数组中的元素出现的次数，这个临时数组是以原始数组中的元素作为索引，元素出现的次数作为值，临时数组创建完毕后，原始数组中不重复的元素已经排序好了，直接循环临时数组，生成排好序的数组就好。

// 主函数
function countingSort(array) {
  if (!Array.isArray(array)) return false;
  if (array.length < 2) return array;

  const maxValue = findMaxValue(array);
  const counts = new Array(maxValue + 1);
  array.forEach(element => {
    if (!counts[element]) {
      counts[element] = 0;
    }
    counts[element]++;
  });

  let sortIndex = 0;
  counts.forEach((count, i) => {
    while (count > 0) {
      array[sortIndex++] = i;
      count--;
    }
  })
  return array;
}
// 查找数组中的最大值
function findMaxValue(array) {
  let maxValue = array[0];
  for (let i = 1; i < array.length; i++) {
    if (array[i] > maxValue) maxValue = array[i];
  }
  return maxValue;
}

7. 桶排序

桶排序也是一种分布式排序算法，将数组划分到不同的桶中，对桶中的小数组进行排序，在组合成排序后的数组。

// 主函数
function bucketSort(array) {
  if (array.length < 2) return array;
  const buckets = createBuckets(array, 3);
  return sortBuckets(buckets);
}
// 划分数组
function createBuckets(array, bucketSize = 3) {
  const { length } = array;
  if (array.length < 2) return array;

  let minValue = array[0];
  let maxValue = array[0];

  for (let i = 1; i < length; i++) {
    if (array[i] < minValue) minValue = array[i];
    if (array[i] > maxValue) maxValue = array[i];
  }

  const buckets = [];
  // 桶的数量
  const bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;
  for (let i = 0; i < bucketCount; i++) {
    buckets[i] = [];
  }

  for (let i = 0; i < length; i++) {
    const bucketIndex = Math.floor((array[i] - minValue) / bucketSize);
    buckets[bucketIndex].push(array[i]);
  }

  return buckets;
}
// 对小数组排序，组合成排序好的大数组
function sortBuckets(buckets) {
  const sortedArray = [];
  for (let i = 0; i < buckets.length; i++) {
    if (buckets[i] != null) {
      insertionSort(buckets[i]);
      sortedArray.push(...buckets[i]);
    }
  }
  return sortedArray;
}

8. 基数排序

  1. 基于每个有效位上的数组进行计数排序，和计数排序不同的地方在于，索引是有效位上的数字，值是有效数字出现的次数。
  2. 对临时数组中的值，进行累计处理，当前值变成当前值加上上一个值，使每个有效数字出现的次数基于上个有效数字做累计。
  3. 每次对数组进行排序时，先获取有效数字，在临时数组中获取累计处理后的值作为索引，对数组进行排序。在这里插入图片描述
function radixSort(array, radix = 10) {
  if (array.length < 2) return array;

  let minValue = array[0];
  let maxValue = array[0];
  let sign = 1;

  for (let i = 0; i < array.length; i++) {
    if (array[i] < minValue) minValue = array[i];
    if (array[i] > maxValue) maxValue = array[i];
  }

  while (Math.floor((maxValue - minValue) / sign) >= 1) {
    array = countingRadixSort(array, sign, minValue, radix);
    sign *= radix;
  }

  return array;
}

function countingRadixSort(array, sign, minValue = 0, radix = 10) {
  let bucketIndex;
  // 保存计数的临时数据
  const buckets = [];
  const aux = [];
  for (let i = 0; i < radix; i++) {
    buckets[i] = 0;
  }

  for (let i = 0; i < array.length; i++) {
    bucketIndex = Math.floor((array[i] - minValue) / sign) % radix;
    buckets[bucketIndex]++;
  }

  // 累计处理
  for (let i = 1; i < radix; i++) {
    buckets[i] += buckets[i - 1];
  }

  for (let i = array.length - 1; i >= 0; i--) {
    bucketIndex = Math.floor((array[i] - minValue) / sign) % radix;
    aux[--buckets[bucketIndex]] = array[i];
  }
  
  for (let i = 0; i < aux.length; i++) {
    array[i] = aux[i];
  }
  return array;
}
奋斗的小栗子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
求根到叶子节点数字之和（C++实现）
炸鸡和薯条的博客
10-29 216
附原题链接：https://leetcode-cn.com/problems/sum-root-to-leaf-numbers 给定一个二叉树，它的每个结点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字。 例如，从根到叶子节点路径 1->2->3 代表数字 123。 计算从根到叶子节点生成的所有数字之和。 说明: 叶子节点是指没有子节点的节点。 示例 1: 输入: [1,2,3] 1 / \ 2 3 输出: 25 解释: 从根到叶...
数据结构之排序
weixin_43859246的博客
06-18 739
排序一、基本概念二、插入类排序1、直接插入排序2、折半插入排序3、希尔排序（缩小增量排序）三、交换类排序1、起泡排序2、快速排序四、选择类排序1、简单选择排序2、树型选择排序3、堆排序五、归并排序六、基于比较的排序对比七、在线性时间内排序1、计数排序2、基数排序 一、基本概念 **排序（sorting）**的功能是将一个数据元素的任意序列，重新排列成一个按关键字有序的 序列。其确切的定义为：假设有n个数据元素的序列{R1 , R2 , … , Rn}，其相应关键字的序列是{K1 , K2 , … , Kn}
数据结构之简单排序算法
weixin_34233679的博客
04-03 85
将数组封装在类中： 1 private int[] arr;//封装的内容包括：数组和数组的长度 2 private int len; 3 public BubbleSortArray(int maxSize){ 4 arr=new int[maxSize]; 5 len=0; 6 } 类中的一些方法： 1 pu...
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
数据结构快速排序算法的实现
12-21
快速排序算法c语言
合并排序 数据结构 排序算法
12-22
合并排序 数据结构 排序算法
数据结构值排序算法.zip
最新发布
01-15
排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法，分支限界...
【数据结构】排序
耕田人的博客
06-05 261
目录 直接插入排序 希尔排序 选择排序 单选 双选 堆排序 冒泡排序 快排 第一种 第二种 乾坤大挪移 第三种 不公平赛跑 快排主函数调用 快排的两种优化 其一 基准值筛选 其二 减少递归深度 归并排序 递归用法 循环用法 总代码及调用实现 直接插入排序 参数：数组指针 / 有效元素个数 依次选取数组中的元...
数据结构-- 递归 排序
weixin_33769207的博客
02-21 248
一.递归 一.递归的介绍递归是一种数学上分而自治的思想A.将原问题分解为规模较小的问题进行处理1.分解后的问题与原问题的类型完全相同，但是规模较小2.通过小规模问题的解，能够轻易求得原问题的解B.问题的分解时有限的(递归不能无限进行)1.当边界条件不满足时，分解问题(递归继续进行)2.当边界条件满足时，直接求解(递归结束)C.递归在程序设计中的应用a.递归函数1.函数体中存在自我调用的函数2.递归...
【数据结构排序算法（一）】直接插入排序
weixin_60053402的博客
03-15 2512
基础数据结构之八大排序算法（一） ① 直接插入排序 时间复杂度：O（n^2） 循环中嵌套循环，一共遍历n的平方次。 空间复杂度：O（1） 所有额外辅助变量不会影响整体问题的规模 稳定性：稳定 没有跨越交换。 （以顺序表作为待排序对象） 基本思想：将一组数据分成两组，一组有序，一组无序，依次从无序数据中取一个数据放到有序数组中。 *以从小到大排列一个数组为例： 比较方式： 第一个数据：11 我们可以直接认为它为有序，因此在我们循环中可以减少一次循环。如下图所示： 运行过程： 代码实现（对顺序表
数据结构排序算法
u012114090的博客
08-10 751
  一、直接插入排序 （1）算法思想：假设第一个数是有序的，那么把后面的数拿出来插入到这个有序数的合适位置，假设是升序（比第一个数小则向后移动第一个数，将数插入到第一个数的前面），插入后有序区间扩大为两个，依次向后，不断拿出新的数插入到有序区间，再扩大这个有序区间直至区间大小等于排序数组的大小。 （2）时间复杂度：时间上，最好情况当序列已经是有序排列了，在这种情况下，需要进行的比较操...
数据结构之四大排序算法
girlling0908的博客
04-18 680
  最近学了几个排序算法，为了加深印象，现在写下来思路。希望各位朋友指正。1.直接插入排序直接插入排序是将元素插入到已经排好序的队列中。 public static void insertSort(int[] a) { for (int i = 0; i &lt; a.length; i++) { int temp = a[i]; int j = i - 1; for (j ...
数据结构——冒泡排序
m0_63020222的博客
03-27 4241
八大排序算法之冒泡排序的实现及改进。
四种排序方法
qwYxK的博客
11-07 1500
排序方法 文章目录排序方法一、常用排序方法1.冒泡排序2.选择排序3.插入排序4.快速排序功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 一、常用排序方法 1.冒泡排序 冒泡排序（Bubble Sort），是一种计算机科学领域的
数据结构排序算法（一）：排序方法分类和各种排序方法的实现
青红造了个大白之成长记
07-08 8225
一、 实验目的1. 掌握各种常用排序的算法思想；2. 掌握各种常用排序的算法实现；3. 掌握各种常用排序时间复杂度，比较各种排序的优缺点。二.排序算法的归类：总的排序算法分为以下几类：1.插入类排序：如：直接插入排序，折半插入排序，希尔排序2.交换类排序：如：冒泡排序，快速排序，其中冒泡排序应该是计算机专业的学生最为熟悉的一种排序算法了，而快速排序则是在冒泡排序的基础上一次消除多个逆序对改进而来3...
数据结构常用算法c语言,数据结构之常见的排序算法c语言实现
weixin_34540951的博客
05-18 153
常见的简单排序算法有冒泡排序、选择排序、插入排序、快排、堆排序、归并排序、希尔排序等，这些排序的理论在网上有很多，这就只给出常见的排序算法源码，上学时候写的，不足之处欢迎大家指正。下面几种排序的主函数入口为：intmain(intargc,char*argv[]){inti,len;inta[]={8,5,6,4,9,10,3,15,2,17};len=(sizeof(a)...
数据结构——常用的排序方法
weixin_46677065的博客
06-16 191
稳定性： 两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。 例：2 3(a) 1 4 3(b) 经过排序后为 结果为： 1 2 3(a) 3(b) 4 稳定排序 结果为： 1 2 3(b) 3(a) 4 不稳定排序 如果一个排序是 稳定的的排序 ，那么他就 可以变为 不稳定的排序但如果一个排序本身是 不稳定排序，你 不可能 把它变为 稳定排序。 稳定排序中一般没有跳跃式交换。 常用的 七个 基
Java实现数据结构与排序算法精要
"本书以Java语言为背景，深入讲解数据结构和排序算法，内容精炼，适合学习或复习。书中涵盖了线性表、栈、队列以及多种排序算法，如选择排序、堆排序、冒泡排序、快速排序、插入排序、Shell排序、归并排序、桶式排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值