Go最新十大排序算法详解(2)，2024年最新2024Golang开发现状分析

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

while 
(left.length)

result.push(left.shift());

while 
(right.length)

result.push(right.shift());

return 
result;

}

|

5. 4 算法分析

最佳情况：T(n) = O(n)  最差情况：T(n) = O(nlogn)  平均情况：T(n) = O(nlogn)

6、快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

6.1 算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

• 从数列中挑出一个元素，称为 “基准”（pivot）；
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

5.2 动图演示

5.3 代码实现

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32
|

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;

}

|

5.4 算法分析

最佳情况：T(n) = O(nlogn)   最差情况：T(n) = O(n2)   平均情况：T(n) = O(nlogn)

7、堆排序（Heap Sort）

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

7.1 算法描述

• 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
• 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
• 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

7.2 动图演示

7.3 代码实现

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44
|

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;

}

|

7.4 算法分析

最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(nlogn) 平均情况：T(n) = O(nlogn)

8、计数排序（Counting Sort）

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

计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

8.1 算法描述

• 找出待排序的数组中最大和最小的元素；
• 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
• 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
• 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

8.2 动图演示

8.3 代码实现

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22
|

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;

}

|

8.4 算法分析

当输入的元素是n 个0到k之间的整数时，它的运行时间是 O(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。

最佳情况：T(n) = O(n+k)  最差情况：T(n) = O(n+k)  平均情况：T(n) = O(n+k)

9、桶排序（Bucket Sort）

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。

桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排

9.1 算法描述

• 设置一个定量的数组当作空桶；
• 遍历输入数据，并且把数据一个一个放到对应的桶里去；
• 对每个不是空的桶进行排序；
• 从不是空的桶里把排好序的数据拼接起来。

9.2 图片演示

9.3 代码实现

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40
|

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;

}

|

9.4 算法分析

桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。

最佳情况：T(n) = O(n+k)   最差情况：T(n) = O(n+k)   平均情况：T(n) = O(n2)

10、基数排序（Radix Sort）

基数排序也是非比较的排序算法，对每一位进行排序，从最低位开始排序，复杂度为O(kn),为数组长度，k为数组中的数的最大的位数；

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。

10.1 算法描述

• 取得数组中的最大数，并取得位数；
• arr为原始数组，从最低位开始取每个位组成radix数组；
• 对radix进行计数排序（利用计数排序适用于小范围数的特点）；

10.2 动图演示

10.3 代码实现

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25
|

//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;

}

}

}

}

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

3 代码实现

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25
|

//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;

}

}

}

}

[外链图片转存中…(img-x5LRTRsA-1715893095029)]
[外链图片转存中…(img-BeLfXVWD-1715893095029)]
[外链图片转存中…(img-tsv2adwD-1715893095029)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取