1.冒泡排序法

前提：元素大小已排序.
时间复杂度：O(n²)（2个嵌套for循环）.
适用：线性表的 顺序存储 & 链式存储 .

冒泡排序法

#include "iostream"
using namespace std;
int BubbleSort(int* array, int* my_len)
{
    if(array==NULL|| my_len==NULL)//负面测试
    {
        return -1;
    }
    int temp = 0;
    int i,j;//前一个元素i，后一个元素j
    for(i = 0; i< *my_len; i++)//嵌套两个for循环，时间复杂度O（n^2）
    {
        for(j = i+1; j < *my_len; j++)
        {
            if(*(array + i) < *(array + j))//交换 <:从大到小 >:从小到大 
            {
                temp = *(array + i);
                *(array + i) = *(array + j);
                *(array + j) = temp;
            }
        }
    }
    return 0;
}




int main()
{
    int arr[] = { 1,3,2,1,66,18,12,77 };
    int *array = arr;//不能直接传递数组名arr，会退化成指针（并且为整个数组指针）而array为单个数组元素指针
    int len = sizeof(arr) / sizeof(*arr);//数组高位 数组名48字节/数组取地址4字节

    //函数调用:BubbleSort()冒泡法
    int ret = BubbleSort(array,&len);
    if (ret == -1)
    {
        cout << "传入空指针！错误码：" << ret << endl;
        return 0;
    }

    for(int i =0; i<len; i++)
    {
        cout <<i<<":"<<arr[i] << endl;
    }
    
    system("pause");

}

2.选择排序法

前提：元素大小已排序.
时间复杂度：O(n²)（2个嵌套for循环）.
适用：线性表的 顺序存储 & 链式存储 .
*优点：相比上种节省内存空间

选择排序法

#include "iostream"
using namespace std;
//交换
int Swap(int* argc, int* argv)
{
    if (argc == NULL&&argv == NULL)
    {
        return -1;
    }

    int temp = 0;
    temp = *argc;
    *argc = *argv;
    *argv = temp;
    return 0;
}

//选择冒泡（version1.0）
int SelectionSort_01(int* array, int* my_len)
{
    if (array == NULL || my_len == NULL)//负面测试
    {
        return -1;
    }

    int i, j;//前一个元素i，后一个元素j


    for (i = 0; i< *my_len-1; i++)//嵌套两个for循环，时间复杂度O（n^2）注意-1
    {
        
        int max = *(array + i);//重置max为之前（i）最大的数!!!
        int temp = i;//如果temp没有变化就让temp =i,自己跟自己交换!!!
        for (j = i+1; j < *my_len; j++)//在后面选最大/小的。
        {
            if ( max < *(array + j))//交换 <:从大到小 >:从小到大 
            {
                max = *(array + j);
                temp = j;
            }
        }
        Swap( (array + temp), (array + i) );
        
    }
    return 0;
}

//选择冒泡（version2.0）
int SelectionSort_02(int* array, int* my_len)
{
    if (array == NULL || my_len == NULL)//负面测试
    {
        return -1;
    }
    int i, j;

    for (i = 0; i < *my_len - 1; i++)
    {
        int max = i;
        for (j = i + 1; j < *my_len; j++)     //走訪未排序的元素
            if (*(array + j) > *(array + max))    //找到目前最小值
                max = j;    //紀錄最小值
        Swap((array + max), (array + i)); //做交換
    }
    return 0;
}





int main()
{
    int arr[] = { 1,3,2,1,66,18,12,77 };
    int *array = arr;//不能直接传递数组名arr，会退化成指针（并且为整个数组指针）而array为单个数组元素指针
    int len = sizeof(arr) / sizeof(*arr);//数组高位 数组名48字节/数组取地址4字节

    //函数调用:SelectionSort();选择排序法
    int ret = SelectionSort_01(array, &len);
    if (ret == -1)
    {
        cout << "传入空指针！错误码：" << ret << endl;
        return 0;
    }

    for (int i = 0; i<len; i++)
    {
        cout << i << ":" << arr[i] << endl;
    }

    system("pause");

}

3.插入排序法

前提：元素大小已排序.
时间复杂度：O(n²)（2个嵌套for循环）.
适用：线性表的 顺序存储 & 链式存储 .

插入排序法

#include "iostream"
using namespace std;


//插入排序
int InsertSort(int* array, int* my_len)
{
    if (array == NULL || my_len == NULL)//负面测试
    {
        return -1;
    }

    int i, j;//前一个元素i，后一个元素j

    int key = 0;
    for (i = 1;i<*my_len;i++)
    {
        key = array[i];
        j = i - 1;
        while ( (j >= 0) && (array[j]<key) ) 
        {
            array[j + 1] = array[j];
            j--;
        }
        array[j + 1] = key;//重新赋值
    }
    return 0;
}






int main()
{
    int arr[] = { 1,3,2,1,66,18,12,77 };
    int *array = arr;//不能直接传递数组名arr，会退化成指针（并且为整个数组指针）而array为单个数组元素指针
    int len = sizeof(arr) / sizeof(*arr);//数组高位 数组名48字节/数组取地址4字节

                                         //函数调用:SelectionSort();选择排序法
    int ret = InsertSort(array, &len);
    if (ret == -1)
    {
        cout << "传入空指针！错误码：" << ret << endl;
        return 0;
    }

    //打印
    for (int i = 0; i<len; i++)
    {
        cout << i << ":" << arr[i] << endl;
    }

    system("pause");
    return 0;

}