使用Python编写冒泡排序

Sure, 冒泡排序是一种简单的排序算法，它通过多次循环遍历待排序的数列，每次比较相邻的两个元素，如果它们的顺序错误就交换它们的位置，这样每次循环会把最大的数放到最后。这里是冒泡排序的 Python 代码实现：

def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
return arr

bubble_sort([5, 2, 7, 1, 9]) # 输出 [1, 2, 5, 7, 9]

相关问题

使用 python 编写冒泡排序和图的 Floyd 算法，并进行用例测试 python

当然，让我们分别介绍冒泡排序算法和Floyd最短路径算法（通常用于寻找无向图中两点之间的最短路径）的Python实现。

**1. 冒泡排序算法**
这是一个简单的排序算法，通过反复交换相邻的未按顺序排列的元素来进行。

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

# 测试用例
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = bubble_sort(arr)
print("Sorted array is:", sorted_arr)

**2. Floyd's Algorithm (Floyd-Warshall) - 适用于邻接矩阵表示的图**
这是求解所有节点对之间最短路径的动态规划算法。

def floyd_warshall(graph):
    V = len(graph)
    dist = graph.copy()  # Copy the graph to keep original distances
    for k in range(V):  # Intermediate nodes
        for i in range(V):
            for j in range(V):
                if dist[i][j] > dist[i][k] + dist[k][j]:  # Relaxation step
                    dist[i][j] = dist[i][k] + dist[k][j]

    return dist

# 示例图，假设是一个邻接矩阵
graph = [[0, 4, 0, 0],
         [4, 0, 8, 0],
         [0, 8, 0, 7],
         [0, 0, 7, 0]]

shortest_paths = floyd_warshall(graph)
print("Shortest paths matrix:")
for path in shortest_paths:
    print(path)

这里`graph`是一个二维列表，其中`graph[i][j]`代表从节点i到节点j的距离。

python编写冒泡排序

好的，我可以帮你解答关于Python编写冒泡排序的问题。以下是示例代码：

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

这是一个基本的冒泡排序实现，时间复杂度为 O(n^2)。如果你有其他问题，可以继续提问。