Go语言的冒泡排序算法以及分治法求出逆序数_冒泡排序可以分治法吗-CSDN博客

本文链接：https://blog.csdn.net/2401_84181108/article/details/138487211

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

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

return cnt

}

func main() {
arr := []int{5, 3, 6, 2, 1, 4}
arr2 := bubbleSort(arr)
fmt.Printf(“%v的逆序数：%v\n”, arr, arr2)
}



> 
> [5 3 6 2 1 4]的逆序数：10  
> 
> 
> 


### Go分治法求逆序数


冒泡法虽然简单直观，但是其时间复杂度比较高 ：**O(n^2)**。  
 我们先来看一个快速但比较复杂点的计算方法是在归并排序的同时计算逆序数，采用分治法其时间复杂度为**O(nlogn)** C++版本：[高级排序求逆序数之分治法](https://bbs.csdn.net/topics/618545628) 可以看出分治法其实属于递归变化的一种高级排序。  
 使用Golang语言来实现，这里我们将使用到切片类型，代码如下：

package main

import (
“fmt”
)

func merge_count(A []int, B []int) (int, []int) {
/*
合并且做了排序并统计逆序数
A列表的值大于B列表的值，就做统计,将B的值(小)添加到C列表
A列表的值小于B列表的值，就将A的值(小)添加到C列表
A和B列表是递归切割出来的
比较剩余之后的值添加到C列表
*/
lenA := len(A)
lenB := len(B)
i := 0
j := 0
rC := 0
var C []int
for i < lenA && j < lenB {
if A[i] > B[j] {
C = append(C, B[j])
j += 1
rC += lenA - i
} else {
C = append(C, A[i])
i += 1
}
}
if i < lenA {
C = append(C, A[i:]…) //切片添加元素需要解包
}
if j < lenB {
C = append(C, B[j:]…)
}
return rC, C
}

func sort_count(L []int) (int, []int) {
/*
递归的切割，然后做合并
*/
if len(L) == 1 {
return 0, L
} else {
rA, A := sort_count(L[0 : len(L)/2])
rB, B := sort_count(L[len(L)/2:])
rC, C := merge_count(A, B) //想明白程序的运行，这里可以做个断点查看
return rA + rB + rC, C
}
}
func main() {
//A := []int{5, 3, 6, 2, 1, 4}
A := []int{11, 5, 3, 6, 2, 9, 1, 4}
fmt.Printf(“%v”, A)
cnt, arr := sort_count(A)
fmt.Printf(“的逆序数：%v,%v”, cnt, arr)
}



> 
> 
> 
> [5 3 6 2 1 4]的逆序数：10,[1 2 3 4 5 6]
> 
> 
> [11 5 3 6 2 9 1 4]的逆序数：19,[1 2 3 4 5 6 9 11]
> 
> 
> 


### Python分治法求逆序数


对Golang不是很了解其语法的，可以先看下Python的方法，思想都是一样的，也就是说算法跟语言没有关系，不同的语言主要在于语法的区别，看个人的习惯。  
 这里用到的是列表，所以数据结构和算法还是核心，需要慢慢积累，另外不同语言的语法就是靠平时写代码过程中的注意和备注

def merge_count(A,B):
‘’’
合并且做了排序并统计逆序数
A列表的值大于B列表的值，就做统计,将B的值(小)添加到C列表
A列表的值小于B列表的值，就将A的值(小)添加到C列表
A和B列表是递归切割出来的
比较剩余之后的值添加到C列表
‘’’
lenA,lenB=len(A),len(B)
i,j,rC=0,0,0
C=[]
while(i<lenA and j<lenB):
if A[i]>B[j]:
C.append(B[j])
j+=1
rC+=lenA-i
else:
C.append(A[i])
i+=1
if i<lenA:
C=C+A[i:]
if j<lenB:
C=C+B[j:]
return (rC,C)