C语言冒泡排序，JAVA冒泡排序加详细解释

最新推荐文章于 2024-09-16 20:08:29 发布

旋转的三板斧

最新推荐文章于 2024-09-16 20:08:29 发布

阅读量37

点赞数 1

分类专栏：算法文章标签： c语言 java 算法

本文链接：https://blog.csdn.net/Niimpa/article/details/133324962

版权

算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

排序思想

一 C语言冒泡排序

#include <stdio.h>

void bubbleSort(int arr[], int n) {
    int temp;
    int swapped;

    // 外循环控制每次冒泡的轮数
    for (int i = 0; i < n - 1; i++) {
        swapped = 0; // 用于标记是否发生了交换

        // 内循环负责一轮中的比较和交换
        for (int j = 0; j < n - 1 - i; j++) {
            // 如果相邻两个元素逆序，则交换它们
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = 1; // 标记发生了交换
            }
        }

        // 如果内循环中没有发生交换，说明数组已经有序，可以提前结束排序
        if (swapped == 0) {
            break;
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("原始数组：\n");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    bubbleSort(arr, n);

    printf("\n排序后的数组：\n");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    return 0;
}

解释：

首先，我们定义了一个 bubbleSort 函数，它接受一个整数数组和数组的大小作为参数，用于执行冒泡排序。
在函数内部，我们定义了一个临时变量 temp 用于交换数组元素，以及一个变量 swapped 用于标记是否发生了交换。
外循环 (for 循环) 控制排序的轮数，从0开始，每轮都会将当前最大的元素移到数组的末尾，因此总共需要进行 n-1 轮排序，其中 n 是数组的大小。
内循环 (for 循环) 负责每一轮中的比较和交换。它从数组的第一个元素开始，依次比较相邻的两个元素，如果它们逆序（前一个元素大于后一个元素），则交换它们。
在内循环结束后，我们检查 swapped 变量的值。如果没有发生交换，说明数组已经是有序的，可以提前结束排序。
在 main 函数中，我们定义了一个整数数组 arr，并初始化了一些示例数据。
接着，我们调用 bubbleSort 函数对数组进行排序。
最后，我们在控制台上打印原始数组和排序后的数组。

冒泡排序的核心思想是不断地比较相邻的两个元素，并在必要时交换它们，通过多次遍历数组来将最大的元素逐渐移动到数组的末尾，从而实现排序。这是一种简单但效率较低的排序算法，其时间复杂度为 O(n^2)，其中 n 是数组的大小。

二 JAVA冒泡排序

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};

        System.out.println("原始数组：");
        printArray(arr);

        bubbleSort(arr);

        System.out.println("\n排序后的数组：");
        printArray(arr);
    }

    public static void bubbleSort(int[] arr) {
        int temp;
        boolean swapped;

        // 外循环控制每次冒泡的轮数
        for (int i = 0; i < arr.length - 1; i++) {
            swapped = false; // 用于标记是否发生了交换

            // 内循环负责一轮中的比较和交换
            for (int j = 0; j < arr.length - 1 - i; j++) {
                // 如果相邻两个元素逆序，则交换它们
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true; // 标记发生了交换
                }
            }

            // 如果内循环中没有发生交换，说明数组已经有序，可以提前结束排序
            if (!swapped) {
                break;
            }
        }
    }

    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

解释：

在上述代码中，我们首先定义了一个 BubbleSort 类，其中包含 main 方法，用于演示冒泡排序的使用。
在 main 方法内，我们定义了一个整数数组 arr 并初始化了一些示例数据。
我们调用 bubbleSort 方法来对数组进行排序。
在 bubbleSort 方法内部，我们定义了一个整数变量 temp 用于交换数组元素，以及一个布尔变量 swapped 用于标记是否发生了交换。
外循环 (for 循环) 控制排序的轮数，从0开始，每轮都会将当前最大的元素移到数组的末尾，因此总共需要进行 arr.length - 1 轮排序，其中 arr.length 是数组的大小。
内循环 (for 循环) 负责每一轮中的比较和交换。它从数组的第一个元素开始，依次比较相邻的两个元素，如果它们逆序（前一个元素大于后一个元素），则交换它们。
在内循环结束后，我们检查 swapped 变量的值。如果没有发生交换，说明数组已经是有序的，可以提前结束排序。
printArray 方法用于打印数组的内容。