js【详解】arr.sort()数组排序（内含十大经典排序算法的js实现）

已于 2024-05-31 15:39:51 修改
阅读量9.3k 收藏 58
点赞数 10
分类专栏： # JavaScript 文章标签： 排序算法 javascript 算法
于 2021-05-14 16:04:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41192489/article/details/116696303
版权

arr.sort()默认按照Unicode编码，从小到大进行排序，会改变原数组

let arr = ["e", "b", "d", "a", "f", "c", 1, 10, 2, 12];
let result = arr.sort()

arr =[1,10,12,2,"a","b","c","d","e","f"]
result =[1,10,12,2,"a","b","c","d","e","f"]

存在的致命缺陷：并没有按数字的大小进行排序，通常无法满足我们对数组的排序需求！

自定义排序规则

给sort()添加一个回调函数，根据回调函数的返回值来自定义排序规则：

  • 如果 返回值 > 0，则元素交换位置
  • 如果 返回值 < 0，则元素位置不变
  • 如果 返回值 = 0，则认为两个元素相等，不交换位置

升序排列

纯数字

let arr = [1, 10, 2, 12];
let ASCarr = arr.sort((a, b) => a - b) // 升序排列 [1,2,10,12]

字符串 + 数字

let arr = ['c', 'a', 'f', 'b', 1, 10, 2, 12];
let ASCarr = arr.sort((a, b) => {
        if (a > b) {
            return 1;
        } else if (a < b) {
            return -1;
        } else {
            return 0;
        }
    }) 

// ["a","b","c","f",1,2,10,12]

降序排列 

纯数字

let arr = [1, 10, 2, 12];
let DESarr = arr.sort((a, b) => b - a) // 降序排列 [12,10,2,1]

字符串 + 数字

let arr = ['c', 'a', 'f', 'b', 1, 10, 2, 12];
let DESarr = arr.sort((a, b) => {
    if (a > b) {
        return -1;
    } else if (a < b) {
        return 1;
    } else {
        return 0;
    }
})

// ["f","c","b","a",12,10,2,1]

混合排序

数组中同时存在数字、字母、汉字等

js 混合排序（同时存在数字、字母、汉字等）_js 中文数字排序-CSDN博客

十大经典排序算法

1. 冒泡排序（Bubble Sort）

数据已经正序时最快，数据是反序时最慢

function bubbleSort(arr) {
    var len = arr.length;
    for (var i = 0; i < len; i++) {
        for (var j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {        //相邻元素两两对比
                var temp = arr[j+1];        //元素交换
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

2. 选择排序（Selection Sort）

时间复杂度 O(n²)，在时间复杂度上表现最稳定的排序算法之一

数据规模越小越好，不占用额外的内存空间

function selectionSort(arr) {
    var len = arr.length;
    var minIndex, temp;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {     //寻找最小的数
                minIndex = j;                 //将最小数的索引保存
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
}

3. 插入排序（Insertion Sort）

function insertionSort(arr) {
    var len = arr.length;
    var preIndex, current;
    for (var i = 1; i < len; i++) {
        preIndex = i - 1;
        current = arr[i];
        while(preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex+1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex+1] = current;
    }
    return arr;
}

4. 希尔排序（Shell Sort）

希尔排序是插入排序的一种更高效率的实现。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。

function shellSort(arr) {
    var len = arr.length,
        temp,
        gap = 1;
    while(gap < len/3) {          //动态定义间隔序列
        gap =gap*3+1;
    }
    for (gap; gap > 0; gap = Math.floor(gap/3)) {
        for (var i = gap; i < len; i++) {
            temp = arr[i];
            for (var j = i-gap; j >= 0 && arr[j] > temp; j-=gap) {
                arr[j+gap] = arr[j];
            }
            arr[j+gap] = temp;
        }
    }
    return arr;
}

5. 归并排序（Merge Sort）

function mergeSort(arr) {  //采用自上而下的递归方法
    var len = arr.length;
    if(len < 2) {
        return arr;
    }
    var middle = Math.floor(len / 2),
        left = arr.slice(0, middle),
        right = arr.slice(middle);
    return merge(mergeSort(left), mergeSort(right));
}
 
function merge(left, right)
{
    var result = [];
 
    while (left.length && right.length) {
        if (left[0] <= right[0]) {
            result.push(left.shift());
        } else {
            result.push(right.shift());
        }
    }
 
    while (left.length)
        result.push(left.shift());
 
    while (right.length)
        result.push(right.shift());
 
    return result;
}

6. 快速排序（Quick Sort）

处理大数据最快的排序算法之一，时间复杂度O(n²)，但在大多数情况下都比平均时间复杂度为O(n log n) 的排序算法表现要更好。

function quickSort(arr, left, right) {
    var len = arr.length,
        partitionIndex,
        left = typeof left != 'number' ? 0 : left,
        right = typeof right != 'number' ? len - 1 : right;
 
    if (left < right) {
        partitionIndex = partition(arr, left, right);
        quickSort(arr, left, partitionIndex-1);
        quickSort(arr, partitionIndex+1, right);
    }
    return arr;
}
 
function partition(arr, left ,right) {     //分区操作
    var pivot = left,                      //设定基准值（pivot）
        index = pivot + 1;
    for (var i = index; i <= right; i++) {
        if (arr[i] < arr[pivot]) {
            swap(arr, i, index);
            index++;
        }       
    }
    swap(arr, pivot, index - 1);
    return index-1;
}
 
function swap(arr, i, j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

7. 堆排序（Heap Sort）

var len;    //因为声明的多个函数都需要数据长度，所以把len设置成为全局变量
 
function buildMaxHeap(arr) {   //建立大顶堆
    len = arr.length;
    for (var i = Math.floor(len/2); i >= 0; i--) {
        heapify(arr, i);
    }
}
 
function heapify(arr, i) {     //堆调整
    var left = 2 * i + 1,
        right = 2 * i + 2,
        largest = i;
 
    if (left < len && arr[left] > arr[largest]) {
        largest = left;
    }
 
    if (right < len && arr[right] > arr[largest]) {
        largest = right;
    }
 
    if (largest != i) {
        swap(arr, i, largest);
        heapify(arr, largest);
    }
}
 
function swap(arr, i, j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
 
function heapSort(arr) {
    buildMaxHeap(arr);
 
    for (var i = arr.length-1; i > 0; i--) {
        swap(arr, 0, i);
        len--;
        heapify(arr, 0);
    }
    return arr;
}

8. 计数排序（Counting Sort）

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。
作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

function countingSort(arr, maxValue) {
    var bucket = new Array(maxValue+1),
        sortedIndex = 0;
        arrLen = arr.length,
        bucketLen = maxValue + 1;
 
    for (var i = 0; i < arrLen; i++) {
        if (!bucket[arr[i]]) {
            bucket[arr[i]] = 0;
        }
        bucket[arr[i]]++;
    }
 
    for (var j = 0; j < bucketLen; j++) {
        while(bucket[j] > 0) {
            arr[sortedIndex++] = j;
            bucket[j]--;
        }
    }
 
    return arr;
}

9. 桶排序（Bucket Sort）

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。
为了使桶排序更加高效，我们需要做到这两点：

  1. 在额外空间充足的情况下，尽量增大桶的数量
  2. 使用的映射函数能够将输入的N个数据均匀的分配到K个桶中
  • 当输入的数据可以均匀的分配到每一个桶中时最快；
  • 当输入的数据被分配到了同一个桶中时最慢；
function bucketSort(arr, bucketSize) {
    if (arr.length === 0) {
      return arr;
    }
 
    var i;
    var minValue = arr[0];
    var maxValue = arr[0];
    for (i = 1; i < arr.length; i++) {
      if (arr[i] < minValue) {
          minValue = arr[i];                //输入数据的最小值
      } else if (arr[i] > maxValue) {
          maxValue = arr[i];                //输入数据的最大值
      }
    }
 
    //桶的初始化
    var DEFAULT_BUCKET_SIZE = 5;            //设置桶的默认数量为5
    bucketSize = bucketSize || DEFAULT_BUCKET_SIZE;
    var bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;   
    var buckets = new Array(bucketCount);
    for (i = 0; i < buckets.length; i++) {
        buckets[i] = [];
    }
 
    //利用映射函数将数据分配到各个桶中
    for (i = 0; i < arr.length; i++) {
        buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
    }
 
    arr.length = 0;
    for (i = 0; i < buckets.length; i++) {
        insertionSort(buckets[i]);                      //对每个桶进行排序，这里使用了插入排序
        for (var j = 0; j < buckets[i].length; j++) {
            arr.push(buckets[i][j]);                      
        }
    }
 
    return arr;
}

10. 基数排序（Radix Sort）

基数排序有两种方法：

  1. MSD 从高位开始进行排序
  2. LSD 从低位开始进行排序

基数排序 vs 计数排序 vs 桶排序

这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：

  • 基数排序：根据键值的每位数字来分配桶
  • 计数排序：每个桶只存储单一键值
  • 桶排序：每个桶存储一定范围的数值
//LSD Radix Sort
var counter = [];
function radixSort(arr, maxDigit) {
    var mod = 10;
    var dev = 1;
    for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
        for(var j = 0; j < arr.length; j++) {
            var bucket = parseInt((arr[j] % mod) / dev);
            if(counter[bucket]==null) {
                counter[bucket] = [];
            }
            counter[bucket].push(arr[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) {
                      arr[pos++] = value;
                }
          }
        }
    }
    return arr;
}

朝阳39
关注
  • 10
    点赞
  • 踩
  • 58
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
sort()排序方法纠正解析
qq_45829293的博客
03-20 1216
目录 1、arr.sort()基本理解 2、错误思想 3、返回顺序不正确的原因 4、正确实现 升序和降序的实现 对象数组排序 对非ASCII字符排序 1、arr.sort()基本理解 arr.sort([compareFunction])此方法对数组元素进行排序 2、错误思想 在我们一般学习印象中sort函数可以直接对数组进行从小到大的默认排序。但是在一次动手输出的过程中，我发现此函数并没有按照预期将数组进行小到大的排序 //未正确排序的例子 -- 将其进行排序，但是未按小到大进
【前端面试】数组排序：array.sort（）方法的理解~
前端之路
10-04 4948
sort() 方法对数组的元素做原地的排序，并返回这个数组。 sort 排序可能是不稳定的。默认按照字符串的Unicode码位点（code point）排序。 语法 arr.sort([compareFunction]) 参数 compareFunction可选。用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的诸个字符的Unicode位点进行排序。 描述 如果没有指
JS中对于数组的常用操作汇总
m0_59415345的博客
06-10 702
在实际应用中，经常需要根据具体需求编写比较函数来实现自定义排序逻辑，比如按照对象的某个属性排序对象数组。map()、find()、some()、sort()
arr.sort()
qq_46544185的博客
02-22 517
arr.sort（）对原数组进行排序，并返回排序后的数组。
JS——数组Array中的sort函数详解
fuzhijieabc的博客
07-25 694
数组中的sort函数详解
js数组(Array, arr)常用的方法
都已经是第二年的立春、又何必执着于、当年的盛​夏呢？
05-11 1874
功能：向末尾添加- 是否接受参数：支持传入多位参数，传入一个就添加一个，传入多位就添加多位- 是否操作源数组：是- 返回：返回添加的数据。
arr.sort排序
yxorg的博客
09-24 1111
1.默认情况下根据字符编码（ascm值）进行排序 var arr = [1,3,6,2,10]arr.sort();//[1, 10, 2, 3, 6]2.sort排序允许接受一个参数（函数），这个函数接受2个形参a,b,并且通过冒泡的方式比较。返回值规则：当返回值为负数时，那么前面的数在前面，也就是不动当返回值为正数时，那么后面的数在前为0，不动升序 arr.sort(function(a,b){ if(a>b){ //返回正数 b就和a位置互换，小的在前面了
JS数组排序sort排序数值、对象中属性、日期
qq_43235503的博客
04-16 777
JS数组排序sort排序数值、对象中属性、日期
排序算法-基于C语言实现的排序算法之ShellSort实现.zip
03-27
**ShellSort算法详解** ShellSort，又称希尔排序，是由美国计算机科学家Donald Shell于1959年提出的一种改进的插入排序算法。它通过将待排序的元素按照一定的间隔分组，然后对每组进行插入排序，随着间隔逐渐减小，...
排序算法-基于C语言实现的排序算法之InsertionSort实现.zip
03-27
其简洁的语法和对底层硬件的良好支持使得它成为实现排序算法的理想选择。C语言的排序算法实现通常涉及到指针操作和数组遍历，这为理解和优化算法提供了直接的途径。 **InsertionSort实现** 插入排序（Insertion ...
堆排序算法详解与实现.zip
最新发布
06-17
"堆排序算法详解与实现.pdf"这份文档可能包含了堆排序的详细理论分析、实例演示以及不同编程语言的实现代码。而"项目说明.pdf"可能提供了更多关于如何应用堆排序到实际项目中的指导和注意事项。 总之，堆排序是一种...
PHP排序算法之冒泡排序(Bubble Sort)实现方法详解
12-20
【冒泡排序（Bubble Sort）】是计算机科学中一种基础且直观的排序算法，尤其适合初学者理解排序的原理。它的基本思想是通过不断地比较数组中的相邻元素并进行交换，使得较大的元素逐步“下沉”到数组的末尾，较小的...
详解js数组的完全随机排列算法
01-21
Array.prototype.sort 方法被许多 JavaScript 程序员误用来随机排列数组。最近做的前端星计划挑战项目中，一道实现 blackjack 游戏的问题，就发现很多同学使用了 Array.prototype.sort 来洗牌。 洗牌 以下就是常见...
数组（arr）的常用方法
Pikachu_999的博客
05-23 3447
【代码】数组（arr）的常用方法。
js sort排序_Javascript中 Array.sort 原理学习
weixin_31880681的博客
12-18 1041
介绍sort()是JS中用来排序的一个方法,在我们学习各种经典排序算法的时候, 发现都“白学”了。其实在代码中一个sort()就可以解决,并且时间复杂度和空间复杂度相对都不会过高。其实sort()不光可以对数组进行排序, 基本数据类型的数组都可以, 并且可以实现对对象数组的排序。这个sort其实远比我们想象的更加智能，它会基于要排序的数据量选择性能更加优秀的排序算法来实现排序。原理为什么...
js排序集合
空&白的博客
02-26 979
arr1(arr) { const len = arr.length; for (let i = 0; i < len - 1; i++) { for (let j = i + 1; j < len; j++) { if (arr[j] < arr[i]) { [arr[j], arr[i]] = [arr[i], arr[j]]; } } } return arr; }, arr2(arr) { const le
JS sort()数组排序方法
qq_45560350的博客
07-28 8307
java.util.Collection类的sort()方法 主要用来给数组拍排序 排序规则可以自己定 默认升序排序 1.Arrays.sort(int[]数组名,int firstIndex起始下标,intlastIndex终止下标); 2.Arrays.sort(int[]数组名);数组已初始化赋值 3.Arrays.sort(int[]数组名,int firstIndex起始下标,intla...
对于js数组排序的问题 arr.sort()
Caster_Saber的专栏
05-10 3357
一般数组排序用的都是 arrayObject.sort(sortby) 但是往往会发现，对于数组中的元素是数字的情况下，实现不了排序，会将数字看成字符进行计算，以至于出现以数字首位为规则进行排序，以至于出现0,11,13,2,29,3,8的类似情况 要解决这种情况，需要另外添加一个函数 function sortNumber(a,b) { return a - b } v
js中数组Array中sort（）函数用法以及原理
leilei7407的博客
05-15 2126
注意：sort() 方法用于对数组的元素进行排序。默认排序顺序为按字母升序排序。 若想使用数字排序，你必须通过一个函数作为参数来调用。通过函数指定数字是按照升序还是降序排列。 sort方法会改变原始数组。 数字升序排序 数字降序排序 js中数组的sort()方法及原理 sort方法可以直接调用，不传入任何参数，也可以传入一个比较函数作为参数。 如果调用sort方法时没有使用参数，会按默认的排序的方式，即先调用每个数组项的toString()，将数组中元素转成字符串类型，然后按AS...
十大排序算法详解python
08-20
当谈到排序算法时，有许多经典的排序算法可以使用。以下是十大常见的排序算法及其详细解释，使用Python编写的示例代码： 1. 冒泡排序（Bubble Sort）： 冒泡排序是一种简单的交换排序算法。它重复地遍历要排序的列表，比较相邻的元素并交换它们，直到整个列表排序完成。 ```python def bubble_sort(arr): n = len(arr) for i in range(n-1): for j in range(n-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] return arr ``` 2. 选择排序（Selection Sort）： 选择排序是一种简单直观的排序算法。它将列表分为已排序和未排序两部分，每次从未排序部分选择最小的元素，并将其放入已排序部分的末尾。 ```python def selection_sort(arr): n = len(arr) for i in range(n-1): min_idx = i for j in range(i+1, n): if arr[j] < arr[min_idx]: min_idx = j arr[i], arr[min_idx] = arr[min_idx], arr[i] return arr ``` 3. 插入排序（Insertion Sort）： 插入排序是一种简单且高效的排序算法。它将列表分为已排序和未排序两部分，每次从未排序部分选择一个元素，并将其插入到已排序部分的正确位置。 ```python def insertion_sort(arr): n = len(arr) for i in range(1, n): key = arr[i] j = i - 1 while j >= 0 and arr[j] > key: arr[j + 1] = arr[j] j -= 1 arr[j + 1] = key return arr ``` 4. 快速排序（Quick Sort）： 快速排序是一种高效的分治排序算法。它选择一个基准元素，将列表分为小于基准值和大于基准值的两部分，然后递归地对这两部分进行排序。 ```python def quick_sort(arr): if len(arr) <= 1: return arr pivot = arr[len(arr) // 2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quick_sort(left) + middle + quick_sort(right) ``` 5. 归并排序（Merge Sort）： 归并排序是一种稳定的排序算法，它采用分治策略将列表分为较小的部分，然后递归地合并这些部分以获得排序结果。 ```python def merge_sort(arr): if len(arr) <= 1: return arr mid = len(arr) // 2 left = arr[:mid] right = arr[mid:] left = merge_sort(left) right = merge_sort(right) return merge(left, right) def merge(left, right): result = [] i, j = 0, 0 while i < len(left) and j < len(right): if left[i] < right[j]: result.append(left[i]) i += 1 else: result.append(right[j]) j += 1 result.extend(left[i:]) result.extend(right[j:]) return result ``` 6. 堆排序（Heap Sort）： 堆排序利用堆的性质进行排序。它将列表视为完全二叉树，并使用堆数据结构来选择最大或最小元素并将其放在正确的位置上。 ```python def heapify(arr, n, i): largest = i left = 2 * i + 1 right = 2 * i + 2 if left < n and arr[i] < arr[left]: largest = left if right < n and arr[largest] < arr[right]: largest = right if largest != i: arr[i], arr[largest] = arr[largest], arr[i] heapify(arr, n, largest) def heap_sort(arr): n = len(arr) for i in range(n // 2 - 1, -1, -1): heapify(arr, n, i) for i in range(n - 1, 0, -1): arr[i], arr[0] = arr[0], arr[i] heapify(arr, i, 0) return arr ``` 7. 计数排序（Counting Sort）： 计数排序是一种稳定的整数排序算法，它使用额外的计数数组来确定每个元素在排序后的位置。它适用于元素范围较小的情况。 ```python def counting_sort(arr): max_val = max(arr) count = [0] * (max_val + 1) for num in arr: count[num] += 1 sorted_arr = [] for i in range(len(count)): sorted_arr.extend([i] * count[i]) return sorted_arr ``` 8. 桶排序（Bucket Sort）： 桶排序是一种将元素分配到

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

朝阳39

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值