冒泡排序之C语言实现与冒泡排序之c++模板实现

冒泡排序

对相邻的两个数进行排序，两两进行比较，选出最大的数，对N个数进行排序的话，需要比较N-1趟，每一趟会选出一个最大的数或者最小的数

第一次交换：

第二次交换：

最后一次交换：

这是第一趟排序，经过这趟排序之后，最大的就在最右边了，也就是排好序了，那么接下来的就是从剩下的三个数中选最大的了，规则和第一趟的一样

C语言实现对数据进行升序和降序排序

使用冒泡排序对数组进行升序排序
代码：

#include<stdio.h>
#include<stdlib.h>
void Bubble_Sort(int arr[], int sz)
{
    int i = 0;
    int j = 0;
    int temp = 0;
    //此层循环是控制趟数（即就是控制对所有的元素进行排序）
    for (i = 0; i < sz-1; ++i)
    {
        /*此层循环是控制第i+1趟（因为i从0开始）所比较的次数，第i+1趟比较了
        N-1-i次（即就是控制某一趟选出最大的元素时，进行两两比较的次数）*/
        for (j = 0; j < sz-1-i; ++j)
        {
            if (arr[j]>arr[j+1])//进行两两比较时，如果左大于右，那就交换顺序，否则不变
            {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}
void test(int arr[], int sz)
{
    int i = 0;
    for (i = 0; i < sz; ++i)
        printf("%d  ", arr[i]);
    printf("\n");
}
int main()
{
    int arr[] = { 2, 4, 6, 7, 8, 1, 9, 34, 27, 12, 56, 23, 30 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    printf("未排序的数组:>   ");
    //输出数组中的元素（此时是未排序的数组）
    test(arr, sz);
    //使用冒泡排对数组中的元素排序
    Bubble_Sort(arr, sz);
    //输出数组中的元素（此时是有序数组）
    printf("已经排好序的数组:>   ");
    test(arr, sz);
    system("pause");
    return 0;
}

运行结果：

使用冒泡排序对数组进行降序排序
代码：

#include<stdio.h>
#include<stdlib.h>
void Bubble_Sort(int arr[], int sz)
{
    int i = 0;
    int j = 0;
    int temp = 0;
    for (i = 0; i < sz-1; ++i)
    {
        for (j = 0; j < sz-1-i; ++j)
        {
            if (arr[j]<arr[j+1])
            {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}
void test(int arr[], int sz)
{
    int i = 0;
    for (i = 0; i < sz; ++i)
        printf("%d  ", arr[i]);
    printf("\n");
}
int main()
{
    int arr[] = { 2, 4, 6, 7, 8, 1, 9, 34, 27, 12, 56, 23, 30 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    printf("未排序的数组:>   ");
    //输出数组中的元素（此时是未排序的数组）
    test(arr, sz);
    //使用冒泡排对数组中的元素排序
    Bubble_Sort(arr, sz);
    //输出数组中的元素（此时是有序数组）
    printf("已经排好序的数组:>   ");
    test(arr, sz);
    system("pause");
    return 0;
}

运行结果：

C++模板实现冒泡排序（int，char，double）

使用模板实现对int型数据进行升序排序
代码：

#include<iostream>
using namespace std;
template<class T>
class Bubble_Sort
{
public:
    Bubble_Sort()
    {}
    void BubbleSort(T arr[], int sz)
    {
        int i = 0;
        int j = 0;
        T temp = 0;
        for (i = 0; i < sz-1; ++i)
        {
            for (j = 0; j<sz-1; ++j)
            {
                if (arr[j] > arr[j+1])
                {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
    void test(T arr[], int sz)
    {
        int i = 0;
        for (i = 0; i < sz; ++i)
        {
            cout<< "   ";
            cout << arr[i];
        }
        cout << endl;
    }
};
int main()
{
    int arr[] = { 1, 4, 5, 7, 9, 2, 3, 6, 8, 0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    Bubble_Sort<int> bubble;
    cout << "未排序的数组:>";
    bubble.test(arr, sz);
    bubble.BubbleSort(arr, sz);
    cout << "已经排好序的数组:>";
    bubble.test(arr, sz);
    system("pause");
    return 0;
}

运行结果：

C++模板实现对char型数据进行升序排序
代码：

#include<iostream>
using namespace std;
template<class T>
class Bubble_Sort
{
public:
    Bubble_Sort()
    {}
    void BubbleSort(T arr[], int sz)
    {
        int i = 0;
        int j = 0;
        T temp = 0;
        for (i = 0; i < sz-1; ++i)
        {
            for (j = 0; j<sz-1; ++j)
            {
                if (arr[j] > arr[j+1])
                {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
    void test(T arr[], int sz)
    {
        int i = 0;
        for (i = 0; i < sz; ++i)
        {
            cout<< "   ";
            cout << arr[i];
        }
        cout << endl;
    }
};
int main()
{
    char arr[] = { 'a','d','a','e','h','t','c','d','b','w','f','o' };
    int sz = sizeof(arr) / sizeof(arr[0]);
    Bubble_Sort<char> bubble;
    cout << "未排序的数组:>";
    bubble.test(arr, sz);
    bubble.BubbleSort(arr, sz);
    cout << "已经排好序的数组:>";
    bubble.test(arr, sz);
    system("pause");
    return 0;
}

运行结果：

C++模板实现对double型数据进行升序排序
代码：

#include<iostream>
using namespace std;
template<class T>
class Bubble_Sort
{
public:
    Bubble_Sort()
    {}
    void BubbleSort(T arr[], int sz)
    {
        int i = 0;
        int j = 0;
        T temp = 0;
        for (i = 0; i < sz-1; ++i)
        {
            for (j = 0; j<sz-1; ++j)
            {
                if (arr[j] > arr[j+1])
                {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
    void test(T arr[], int sz)
    {
        int i = 0;
        for (i = 0; i < sz; ++i)
        {
            cout<< "   ";
            cout << arr[i];
        }
        cout << endl;
    }
};
int main()
{
    double arr[] = { 2.2,1.1,6.6,0.6,7.8,9.3,4.5,3.3,11.11,23.23,8.88 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    Bubble_Sort<double> bubble;
    cout << "未排序的数组:>";
    bubble.test(arr, sz);
    bubble.BubbleSort(arr, sz);
    cout << "已经排好序的数组:>";
    bubble.test(arr, sz);
    system("pause");
    return 0;
}

运行结果：

冒泡排序的时间复杂度

4个数排序完需要3趟，第一趟需要比较3次，第二趟需要比较2次，第三趟需要比较1次，那一共比较了3+2+1=6次

假如有个N个数需要排序

需要排（n-1）+（n-2）+……+2+1次，这是一个等差数列
（n-1）+（n-2）+……+2+1=n^2 / 2 -n / 2
根据时间复杂度的规则，去掉最低项（n/2),并去掉常数系数，那复杂度就是O(n^2)