求逆序数的方法主要有以下几种：
暴力法
描述：遍历数组中的每一对元素，如果前面的元素大于后面的元素，则逆序对个数加1。
时间复杂度：O（n^2），其中n为数组的长度。
代码示例：
```python
def count_inversions（arr）:
count = 0
n = len（arr）
for i in range（n）:
for j in range（i+1, n）:
if arr[i] > arr[j]:
count += 1
return count
```
归并排序法
描述：基于分治思想，将数组分成两个子数组，分别进行排序，然后合并时统计逆序对个数。
时间复杂度：O（nlogn），其中n为数组的长度。
代码示例：
```python
def merge_sort（arr）:
if len（arr） <= 1:
return 0
mid = len（arr） // 2
left_count = merge_sort（arr[:mid]）
right_count = merge_sort（arr[mid:]）
count = left_count + right_count
i = j = k = 0
while i < len（left_arr） and j < len（right_arr）:
if left_arr[i] <= right_arr[j]:
arr[k] = left_arr[i]
i += 1
else:
arr[k] = right_arr[j]
j += 1
count += len（left_arr） - i
k += 1
while i < len（left_arr）:
arr[k] = left_arr[i]
i += 1
k += 1
while j < len（right_arr）:
arr[k] = right_arr[j]
j += 1
k += 1
return count
```
树状数组
描述：利用树状数组（Binary Indexed Tree）在合并过程中高效地计算逆序对。
时间复杂度：O（nlogn），其中n为数组的长度。
代码示例：
```python
class BinaryIndexedTree:
def __init__（self, n）:
self.n = n
self.c = * （n + 1）
@staticmethod
def lowbit（x）:
return x & -x
def update（self, x, delta）:
while x <= self.n:
self.c[x] += delta
x += BinaryIndexedTree.lowbit（x）
def query（self, x）:
s = 0
while x > 0:
s += self.c[x]
x -= BinaryIndexedTree.lowbit（x）
return s
def count_inversions_tree（arr）:
n = len（arr）
tree = BinaryIndexedTree（n）
count = 0
for i in range（n - 1, -1, -1）:
count += tree.query（arr[i] - 1）
tree.update（arr[i], 1）
return count
```
这些方法各有优缺点，暴力法简单直观但时间复杂度较高；归并排序法效率较高，但实现相对复杂；树状数组方法在处理大规模数据时表现优异，但需要额外的空间。根据具体需求和数据规模，可以选择合适的方法来计算逆序数。