Algorithm 使用大O表示法分析这些算法（使用比较次数和复制操作次数）

这是我的“优化”气泡排序的代码：

import random
n = 20                              #Create Variable for length of the array
array = []                          #Create array
y = 0
z = 0

for i in range(n):      #Generate random elements to fill the array to specified length
    x = random.randint(1, 1000)
    array.append(x)




for i in range(n-1):                #Create a for loop with range (length of array - 1)
    for e in range(0, n-1):       #Create a for loop with range (length of array - incremented integer of loop - 1)
        if array[e] > array[e+1]:  #If position is greater than next position: 
            array[e], array[e+1] = array[e+1], array[e] #Swap the elements
        y = y + 1
    z = z + 1
print("""BubbleSort.py

Sorted Array: """, array)
print("Number of Times Scanned: ", z, ", With A Total Of: ", y, " Comparisons.")

import random
n = 20                              #Create Variable for length of the array
array = []                          #Create array
y = 0
z = 0

for i in range(n):      #Generate random elements to fill the array to specified length
    x = random.randint(1, 1000)
    array.append(x)




for i in range(n-1):                #Create a for loop with range (length of array - 1)
    for e in range(0, n-1):       #Create a for loop with range (length of array - incremented integer of loop - 1)
        if array[e] > array[e+1]:  #If position is greater than next position: 
            array[e], array[e+1] = array[e+1], array[e] #Swap the elements
        y = y + 1
    z = z + 1
print("""BubbleSort.py

Sorted Array: """, array)
print("Number of Times Scanned: ", z, ", With A Total Of: ", y, " Comparisons.")

这是我的普通气泡排序的代码：

import random
n = 20                              #Create Variable for length of the array
array = []                          #Create array
y = 0
z = 0

for i in range(n):      #Generate random elements to fill the array to specified length
    x = random.randint(1, 1000)
    array.append(x)




for i in range(n-1):                #Create a for loop with range (length of array - 1)
    for e in range(0, n-1):       #Create a for loop with range (length of array - incremented integer of loop - 1)
        if array[e] > array[e+1]:  #If position is greater than next position: 
            array[e], array[e+1] = array[e+1], array[e] #Swap the elements
        y = y + 1
    z = z + 1
print("""BubbleSort.py

Sorted Array: """, array)
print("Number of Times Scanned: ", z, ", With A Total Of: ", y, " Comparisons.")

import random
n = 20                              #Create Variable for length of the array
array = []                          #Create array
y = 0
z = 0

for i in range(n):      #Generate random elements to fill the array to specified length
    x = random.randint(1, 1000)
    array.append(x)




for i in range(n-1):                #Create a for loop with range (length of array - 1)
    for e in range(0, n-1):       #Create a for loop with range (length of array - incremented integer of loop - 1)
        if array[e] > array[e+1]:  #If position is greater than next position: 
            array[e], array[e+1] = array[e+1], array[e] #Swap the elements
        y = y + 1
    z = z + 1
print("""BubbleSort.py

Sorted Array: """, array)
print("Number of Times Scanned: ", z, ", With A Total Of: ", y, " Comparisons.")

我的大脑今天变得迟钝，不知什么原因，我无法专心分析这些。 我以为它是n（n-1）/2，用于比较，n-1表示正常情况下的复制操作，但我意识到这似乎不正确

两者的比较和复制操作是什么？我如何计算

---

谢谢。

首先，我不能完全确定您的语法。当你写这样的东西时

for i in range(n - timesscanned)
  ...
  timesscanned = timesscanned + 1

范围是在循环开始时只评估一次还是在循环的每次迭代中评估一次？如果它是第一个，则

范围内的
timescanned
无效，因为它已初始化为0。如果是第二个，则优化算法是错误的，因为它只处理数组的一半

你似乎也有不同类型的射程。有一次你写信

for i in range(0, n)

for i in range(numOfElements)

下次你再写信

for i in range(0, n)

for i in range(numOfElements)

这两者有什么区别

其次，“优化”方法在变量
y
中计算的不是比较的数量，而是交换的数量，因为只有当两个比较的值顺序错误时，才增加该值

第三，变量
timescanned
和
z
之间有什么区别？对于外部循环的每次迭代，它们都初始化为0并递增。根据范围的语义（见上文），它们最终都是
n
或
n/2

最后，是的，比较次数的最坏情况（在naive实现中也是“始终”情况）是O（n^2），交换次数的最坏情况（在按降序排序的数组中）也是O（n^2）

编辑

要优化bubble sort的朴素版本，您可以做以下两件事

与外部循环的每次迭代一样，当前未排序的最大元素在数组末尾“冒泡”。因此，在外循环的第次迭代中，内循环不再需要迭代整个数组，而是可以跳过检查最后的
x
元素


如果在内部循环的一次迭代中根本没有发生交换，那么数组将正确排序。因此，算法可以停止。naive方法将执行所有迭代和检查，即使原始数组已经排序。优化版本将只迭代一次排序数组


对不起，我的愚蠢代码，我已经把它修好了一点。所以首先，我已经摆脱了时间扫描，离开了z。“for i in range（n-timescanned）（现在的n-z）的范围在每个循环的开始处进行评估。但是我不确定你的意思是什么，它只处理数组的一半，因为运行时它工作正常。其次，我已经修复了y的位置，所以它会计算比较的次数，谢谢。如果
range（n-z）
在每次迭代时进行计算，
z
在该循环的每次迭代中递增，这相当于
范围（n/2）
。因此，外循环仅迭代n/2次。但在外循环的每次迭代中，只有一个元素可以放置在其正确的位置。因此，如果有n个元素要排序，则需要对外循环进行n次迭代，但只有n/2次。如果数组不是“太未排序”，则它可能会工作，但它不会解决最坏的情况（反向排序数组）。顺便说一句，编辑后，两个代码块是相同的