冒泡排序（从前向后VS从后向前）

R-G-B

已于 2022-05-02 20:37:10 修改

阅读量1.9k

点赞数 3

分类专栏：算法文章标签：排序算法算法 c++

于 2022-05-02 20:35:47 首次发布

本文链接：https://blog.csdn.net/m0_51233386/article/details/124545751

版权

算法专栏收录该内容

61 篇文章 2 订阅

订阅专栏

本文详细介绍了冒泡排序的两种实现方式，包括从前向后和从后向前，并通过添加flag标志来优化排序效率，减少不必要的比较。同时，讲解了如何使用sizeof和strlen计算数组和字符串的长度，以及它们的适用场景。通过实例展示了排序过程及所需趟数，帮助理解冒泡排序的工作原理。

摘要由CSDN通过智能技术生成

参考：冒泡排序从前向后/从后向前实现

1 简单实现

//j =0从前向后
void BubbleSort1(int A[], int n) {//从小到大
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - 1 - i; j++)//从前向后比较,将最大的移动到最后面，后面逐渐有序
        {
            if (A[j] > A[j + 1])
            {
                swap(A[j], A[j + 1]);
            }
        }
    }
}

//j = n - 1从后向前
void BubbleSort2(int A[], int n) {//从小到大
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = n - 1; j > i; j--)//从后向前比较，将最小的移动到最前面，前面逐渐有序
        {
            if (A[j - 1] > A[j])
            {
                swap(A[j - 1], A[j]);
            }
        }
    }
}

调用测试

#include <iostream>
void BubbleSort1(int A[], int n);
void BubbleSort2(int A[], int n);
void Print(int A[], int n);
using namespace std;

int main()
{
    int arr1[] = { 29, 50, 90, 52, 15, 67, 60, 45, 5 };
    int len1 = (int)sizeof(arr1) / sizeof(*arr1);
    Print(arr1, len1);
    BubbleSort1(arr1, len1);
    Print(arr1, len1);

    int arr2[] = { 29, 50, 90, 52, 15, 67, 60, 45, 5 };
    int len2 = (int)sizeof(arr1) / sizeof(*arr1);
    Print(arr2, len2);
    BubbleSort2(arr2, len2);
    Print(arr1, len1);

    return 0;
}

//j =0从前向后
void BubbleSort1(int A[], int n) {//从小到大
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - 1 - i; j++)//从前向后比较,将最大的移动到最后面，后面逐渐有序
        {
            if (A[j] > A[j + 1])
            {
                swap(A[j], A[j + 1]);
            }
        }
    }
}
//j = n - 1从后向前
void BubbleSort2(int A[], int n) {//从小到大
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = n - 1; j > i; j--)//从后向前比较，将最小的移动到最前面，前面逐渐有序
        {
            if (A[j - 1] > A[j])
            {
                swap(A[j - 1], A[j]);
            }
        }
    }


}


void Print(int A[], int n) {
    for (int i = 0; i < n; i++)
    {
        cout << A[i] << " ";
    }
    cout << endl;
}

在这里插入图片描述

2 加入flag改进，提高效率

冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序，提前结束循环。

//升序
//从前向后比较,将最大的移动到最后面，后面逐渐有序
void BubbleSort1(int A[], int n) {
    bool flag;//排序是否发生交换标志，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序
    for (int i = 0; i < n - 1; i++){
        flag = false;
        for (int j = 0; j < n - 1 - i; j++){//j只能取到j=n - i - 2
            if (A[j] > A[j + 1]){
                swap(A[j], A[j + 1]);
                flag = true;		// 只有交换了flag才为true
            }
        }
        if (flag == false)//本趟遍历未发生交换，说明已有序，冒泡完成，提前结束循环
            return;    
}

//升序
void BubbleSort2(int A[], int n) {
标志，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序
    for (int i = 0; i < n - 1; i++) {	// n-1趟冒泡
        flag = false;
        for (int j = n - 1; j > i; j--)	// 从后向前
            if (A[j - 1] > A[j]) {	//若前面比后面的数大，则交换
                swap(A[j - 1], A[j]);
                flag = true;		// 只有交换了flag才为true
            }
        if (flag == false)
            return;
    }
}

3 输出排序过程，完成需要趟数

//升序
//从前向后比较,将最大的移动到最后面，后面逐渐有序
void BubbleSort1(int A[], int n) {
    cout << "j=0，从前向后比，排序过程： " << endl;
    bool flag;//排序是否发生交换标志，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序
    for (int i = 0; i < n - 1; i++){
        flag = false;
        for (int j = 0; j < n - 1 - i; j++){//j只能取到j=n - i - 2
            if (A[j] > A[j + 1]){
                swap(A[j], A[j + 1]);
                flag = true;		// 只有交换了flag才为true
            }
        }
        if (flag == false){//本趟遍历未发生交换，说明已有序，冒泡完成，提前结束循环
            cout << "共" << i << "趟完成排序；第" << i + 1 << "趟退出循环" << endl << endl;
            return;
        }
        cout << "第" << i + 1 << "趟排序结果 " << endl;
        Print(A, n);
    }
    //如果，n-1趟才完成排序，没有提前借排序
    cout << "共" << n-1 << "趟完成排序；"<< endl << endl;
}

完整测试代码

#include <iostream>
void BubbleSort1(int A[], int n);
void BubbleSort2(int A[], int n);
void Print(int A[], int n);
using namespace std;

int main()
{
    int arr1[] = { 29, 50, 90, 52, 15, 67, 60, 45, 5 };
    int len1 = (int)sizeof(arr1) / sizeof(*arr1);
    Print(arr1, len1);
    BubbleSort1(arr1, len1);

    int arr2[] = { 29, 50, 90, 52, 15, 67, 60, 45, 5 };
    int len2 = (int)sizeof(arr1) / sizeof(*arr1);
    Print(arr2, len2);
    BubbleSort2(arr2, len2);

    return 0;
}

//升序
//从前向后比较,将最大的移动到最后面，后面逐渐有序
void BubbleSort1(int A[], int n) {
    cout << "j=0，从前向后比，排序过程： " << endl;
    bool flag;//排序是否发生交换标志，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序
    for (int i = 0; i < n - 1; i++){
        flag = false;
        for (int j = 0; j < n - 1 - i; j++){//j只能取到j=n - i - 2
            if (A[j] > A[j + 1]){
                swap(A[j], A[j + 1]);
                flag = true;		// 只有交换了flag才为true
            }
        }
        if (flag == false){//本趟遍历未发生交换，说明已有序，冒泡完成，提前结束循环
            cout << "共" << i << "趟完成排序；第" << i + 1 << "趟退出循环" << endl << endl;
            return;
        }
        cout << "第" << i + 1 << "趟排序结果 " << endl;
        Print(A, n);
    }
    //如果，n-1趟才完成排序，没有提前借排序
    cout << "共" << n-1 << "趟完成排序；"<< endl << endl;
}

//升序
//从后向前比较，将最小的移动到最前面，前面逐渐有序
void BubbleSort2(int A[], int n) {
    cout << " j = n - 1，从后向前比，排序过程： " << endl;
   
    bool flag;//排序是否发生交换标志，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序
    for (int i = 0; i < n - 1; i++) {	// n-1趟冒泡
        flag = false;
        for (int j = n - 1; j > i; j--)	// 从后向前
            if (A[j - 1] > A[j]) {	//若前面比后面的数大，则交换
                swap(A[j - 1], A[j]);
                flag = true;		// 只有交换了flag才为true
            }
        if (flag == false){//本趟遍历未发生交换，说明已有序，冒泡完成，提前结束循环
            cout << "共" << i << "趟完成排序；第" << i + 1 << "趟退出循环" << endl << endl;
            return;
        }
        cout << "第" << i + 1 << "趟排序结果 " << endl;
        Print(A, n);
    }
    //如果，n-1趟才完成排序，没有提前借排序
    cout << "共" << n - 1 << "趟完成排序；" << endl << endl;
}

void Print(int A[], int n) {
    for (int i = 0; i < n; i++)
    {
        cout << A[i] << " ";
    }
    cout << endl;
}

在这里插入图片描述

4.数组和字符串长度sizeof与strlen

C语言中数组长度的计算方法总结（sizeof与strlen）

1 sizeof求解数组长度

sizeof能计算变量或者数据类型所占用的内存（以字节为单位）。用sizeof计算数组长度时，sizeof不关心数组内部存储的是什么类型的数据。

所以常常用 sizeof(arr)/sizeof(arr[0]) 来计算数组的长度。其中“sizeof(arr)“计算了整个数组arr占据了多少内存（字节为单位），”sizeof(arr[0])“计算了数组中第一个元素所占多少字节，两者相除就是数组的长度。

int arr [10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};//定义了元素个数，且给所有元素均赋值
int len= sizeof(arr) / sizeof(arr [0]);

2 strlen求解字符串长度

char arr[] = "abc";//没有定义元素个数，用双引号定义3个字符，末尾数组会自动加上结束标志（\0)
strlen(arr));

3 总结

总结：

定义数组时，要先明确数组的类型（int还是char或者其他类型）。

sizeof不能用来计算已经定义好长度的数组的数组长度（如int arr[10] = {0}，不能有中括号里的10）。

strlen不能用来计算int类型的数组长度。

int型计算数组长度，最好用 sizeof(arr) / sizeof(arr[0]) 来计算数组长度。

char型数组如果要计算数组长度，一定要用双引号赋值。

char型数组如果要用大括号赋值，一定要注意数组最后是否需要结束标志 \0

R-G-B

关注

3
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
0
评论
冒泡排序（从前向后VS从后向前）

文章目录1 简单实现2 加入flag改进，提高效率3 输出排序过程，排序完趟数4.数组和字符串长度sizeof与strlen1 sizeof求解数组长度2 strlen求解字符串长度3 总结参考：冒泡排序从前向后/从后向前实现1 简单实现//j =0从前向后void BubbleSort1(int A[], int n) {//从小到大 for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - 1
复制链接

扫一扫