关于排序查找时间复杂度的一些简单测试(个人学习)

最新推荐文章于 2024-05-05 13:57:09 发布

lovely2610

最新推荐文章于 2024-05-05 13:57:09 发布

阅读量778

点赞数 23

分类专栏：个人学习博客文章标签：学习排序算法算法

本文链接：https://blog.csdn.net/lovely2610/article/details/134753281

版权

个人学习博客专栏收录该内容

5 篇文章 0 订阅

订阅专栏

时间复杂度的含义

在计算机科学中，算法的时间复杂度（time complexity）是一个函数，它定性描述该算法的运行时间。这是一个代表算法输入值的字符串的长度的函数。时间复杂度常用大O符号表述，不包括这个函数的低阶项和首项系数。使用这种方式时，时间复杂度可被称为是渐近的，亦即考察输入值大小趋近无穷时的情况。

时间复杂度的意义

时间复杂度高低会影响计算机运行函数的速度，从而影响性能等。

排序查找时间复杂度解释

①线性查找

7, 18, 19, 100, 130, 300, 500, 501, 1321,........n

如果数字是N条，那么最坏的情况就需要计算N次，

时间复杂度： O(n)=n

python代码：

def search(arr, n, x): 
  
    for i in range (0, n): 
        if (arr[i] == x): 
            return i 
    return -1 

arr = [45, 64, 34, 25, 12, 22, 11, 90]
x = 90
n = len(arr) 
result = search(arr, n, x) 
if(result == -1): 
    print("元素不在数组中") 
else: 
    print("元素在数组中的索引为", result)

②二分查找

7, 18, 19, 100, 130, 300, 500, 501, 1321,........n

我们要找的是：1321，先看中间的数字开始找

时间复杂度，数组的长度是N，那么：O(N)=log2(N)

python代码：

def binary_search(arr, left, right, x):
    if right >= left:
        mid = (left + right) // 2

        if arr[mid] == x:
            return mid
        elif arr[mid] > x:
            return binary_search(arr, left, mid - 1, x)
        else:
            return binary_search(arr, mid + 1, right, x)
    else:
        return None

arr = [45, 64, 34, 25, 12, 22, 11, 90]
x = 90
result=binary_search(arr, 0, len(arr) - 1, x)
print(f"元素 {x} 在索引 {result} 处找到")

③归并排序

原数组 = [45, 64, 34, 25, 12, 22, 11, 90] 》》输出正序数组

不断将原数组拆分成更小的数组，将拆分后的数组两两对比，更小的数字放在数组前面。

归并的时间复杂度： O(n)=n∗log2(n)

python代码：

def merge(arr, left, right, mid):
    n1 = mid - left +1
    n2 = right - mid

    L = [0]*(n1)
    R = [0]*(n2)

    #把旧的数组的值给一个新的数组(左边的小数组)
    for i in range(0, n1):
        L[i] = arr[left+i]

    for j in range(0, n2):
        R[j] = arr[mid+1+j]

    i = 0
    j = 0
    k = left

    #合并数组
    while i < n1 and j < n2:
        if L[i] <= R[j]:
            arr[k] = L[i]
            i +=1
        else:
            arr[k] = R[j]
            j +=1
        k +=1

    #处理剩余数组
    while i < n1:
        arr[k] = L[i]
        k +=1
        i +=1

    while j< n2:
        arr[k] = R[j]
        k += 1
        j += 1


def merge_sort(arr, left, right):
    if left < right:
        mid = (left + right)// 2
        merge_sort(arr, left, mid)
        merge_sort(arr, mid + 1, right)
        merge(arr, left, right , mid)
  
arr = [45, 64, 34, 25, 12, 22, 11, 90]
merge_sort(arr, 0, len(arr)-1)
merge(arr,0,8,len(arr) // 2)
print(arr)

④冒泡排序

将一个无序数组，逐个跟后一个数字比较，如果更大就后移，如果更小就停下继续移动后一个数字，直至变为一个正序数组。

时间复杂度是 O(N)=N^2

python代码：

def bubbleSort(arr):
    n = len(arr)
 
    # 遍历所有数组元素
    for i in range(n):
 
        # Last i elements are already in place
        for j in range(0, n-i-1):
 
            if arr[j] > arr[j+1] :
                arr[j], arr[j+1] = arr[j+1], arr[j]
 
arr = [64, 34, 25, 12, 22, 11, 90]
 
bubbleSort(arr)
 
print ("排序后的数组:")
for i in range(len(arr)):
    print ("%d" %arr[i]),

测试准备

测试环境python3.12

测试软件VScode

测试使用代码

①测试时间记录

# 使用timeit测量函数的执行时间
time_taken = timeit.timeit(lambda: search(arr, n, x), number=10)
# 打印执行时间（单位：秒）
print(f"执行时间: {time_taken} 秒")

②倒序10000的数组

def create_arr():
    arr1 = []
    j = 10000
    for i in range(10001):
        arr1.append(j)
        j -= 1
    return arr1
arr = []
arr = create_arr()