普通冒泡排序sqlist

以下是普通冒泡排序sqlist的Python实现代码：

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

以上代码中，我们定义了一个名为`bubble_sort`的函数，该函数接受一个列表`sqlist`作为参数，并返回排序后的列表。在函数内部，我们首先获取列表的长度，然后使用两个嵌套的循环来遍历列表。外层循环控制排序的轮数，内层循环则用于比较相邻的元素并进行交换。如果前一个元素大于后一个元素，则交换它们的位置。最终，我们返回排序后的列表。

相关问题

C语言用顺序表采用冒泡排序对随机生成的30个数进行排序

好的，下面是用 C 语言实现的顺序表冒泡排序代码：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX_SIZE 30  // 定义数组最大长度

typedef struct {
    int data[MAX_SIZE];  // 数组存储数据元素，最大长度为 MAX_SIZE
    int length;  // 当前长度
} SqList;

void init_list(SqList *L) {
    L->length = 0;
}

void print_list(SqList L) {
    for (int i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");
}

void bubble_sort(SqList *L) {
    for (int i = 0; i < L->length-1; i++) {
        for (int j = 0; j < L->length-i-1; j++) {
            if (L->data[j] > L->data[j+1]) {
                // 交换 L->data[j] 和 L->data[j+1] 的值
                int temp = L->data[j];
                L->data[j] = L->data[j+1];
                L->data[j+1] = temp;
            }
        }
    }
}

int main() {
    SqList L;
    init_list(&L);
    srand(time(NULL));  // 以时间为种子，随机生成 30 个数
    printf("随机生成的 30 个数：\n");
    for (int i = 0; i < 30; i++) {
        L.data[i] = rand() % 100;  // 产生 0 到 99 之间的随机数
        L.length++;
    }
    print_list(L);
    bubble_sort(&L);
    printf("冒泡排序后的结果：\n");
    print_list(L);
    return 0;
}

运行结果：

随机生成的 30 个数：
68 94 71 98 15 45 26 98 90 90 6 39 77 11 56 20 99 64 46 9 31 49 21 58 60 67 12 62 5 7
冒泡排序后的结果：
5 6 7 9 11 12 15 20 21 26 31 39 45 46 49 56 58 60 62 64 67 68 71 77 90 90 94 98 98 99

希望能帮到你！

设计一待排序的线性表以顺序存储结构存储，试写出冒泡排序和直接插入排序算法。

好的，我来回答你的问题。

首先，我们可以使用数组来实现待排序的线性表以顺序存储结构存储。比如以下代码：

#define MAXSIZE 100  // 定义线性表的最大长度

typedef struct {
    int data[MAXSIZE];  // 用数组存储线性表的元素
    int length;  // 记录线性表的当前长度
} SqList;

接下来，我将分别介绍冒泡排序和直接插入排序算法。

1. 冒泡排序

冒泡排序的基本思想是，每次比较相邻的两个元素，如果它们的顺序不对就交换它们的位置，这样一轮比较下来，最大的元素就会“冒泡”到最后面，然后再对前面的元素重复进行相邻元素比较和交换的操作，直到整个序列有序为止。

以下是冒泡排序的代码实现：

void bubbleSort(SqList *L) {
    int i, j;
    for (i = 0; i < L->length - 1; i++) {
        for (j = 0; j < L->length - i - 1; j++) {
            if (L->data[j] > L->data[j+1]) {
                int temp = L->data[j];
                L->data[j] = L->data[j+1];
                L->data[j+1] = temp;
            }
        }
    }
}

2. 直接插入排序

直接插入排序的基本思想是，将一个元素插入到已经排好序的序列中，使得插入后序列仍然有序。具体实现时，将待插入的元素与已排序的元素从后往前逐一比较，找到插入位置后将该元素插入到相应位置。

以下是直接插入排序的代码实现：

void insertSort(SqList *L) {
    int i, j;
    for (i = 1; i < L->length; i++) {
        int temp = L->data[i];
        for (j = i - 1; j >= 0 && L->data[j] > temp; j--) {
            L->data[j+1] = L->data[j];
        }
        L->data[j+1] = temp;
    }
}

以上就是冒泡排序和直接插入排序的算法实现。希望能对你有所帮助。