简单排序

---

• 原理
• 举例
• 程序代码
• 时间复杂度

---

（一）选择排序

原理：

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

选择排序就是不断地从未排序的元素中选择最大（或者最下）的元素放入已经排好序的元素集合中，直到未排序中仅剩一个元素为止

使用选择排序对数组进行 降序排序 :

代码：

#include<stdio.h>
#include<stdlib.h>
void Select_Sort(int arr[], int sz)//选择排序
{
    int i = 0;//i表示有序数组的下标
    int j = 0;//j表示无序数组的下标
    int minIndex = 0;//最小元素的下标
    int temp = 0;
    //控制对所有元素排序（第一个元素排好之后，有序空间的下标往后移动，开始排后面的元素
    for (i = 0; i < sz; i++)
    {
        minIndex = i;//最小值默认是无序空间第一个元素的下标（也就是i)
        //负责在无序空间中找到最小的元素，更新下标minIndx
        for (j = i + 1; j < sz; j++)
        {
            if (arr[minIndex]<arr[j])
                minIndex = j;//更新最小值的下标
        }
        /*第一次时比较开始前，默认数组的第一个元素是整个数组元素中最小
        的（即就是默认arr[0]是有序空间最小的元素，然后用它与无序空间
        中的最小值比较，从而得到排好序数组的最小元素*/
        //选择出最小的元素，放到有序空间中
        if (arr[i] < arr[minIndex])
        {
            temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }
}
void test(int arr[], int sz)
{
    for (int i = 0; i < sz; ++i)
        printf("%d ", arr[i]);
    printf("\n");
}
int main()
{
    int arr[] = { 2, 5, 6, 1, 8, 0, 4, 6, 8, 7, 9 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    printf("未排序的数组:>  ");
    test(arr,sz);//输出数组中的元素
    Select_Sort(arr, sz);//选择排序
    printf("已经排好序的数组:>  ");
    test(arr, sz);
    system("pause");
    return 0;
}

运行结果：





选择排序的 时间复杂度 : 假设有N个元素需要排序

外层for循环的时间复杂度：

O(N)

内层for循环的时间复杂度：

i=0时，比较N-1次
i=1时，比较N-2次
……
i=N-2时，比较1次
则一共比较了（N-1）+(N-2)+……+2+1=N^2 / 2 - N / 2

故时间复杂度为 O(N^2)

---

（二）冒泡排序

原理：

（以递增序为例）是每次从头开始依次比较相邻的两个元素，如果后面一个元素比前一个要大，说明顺序不对，则将它们交换，本次循环完毕之后再次从头开始扫描，直到某次扫描中没有元素交换，说明每个元素都不比它后面的元素大，至此排序完成。

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

使用冒泡排序对数组进行 升序排序 :

代码：

#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++ 模板实现对 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)

故时间复杂度为 O(N^2)

---

（三）插入排序

原理：

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

就是一种比较简单直观的排序算法，适用处理数据量比较少或者部分有序的数据

使用插入排序对数组进行 升序排序 :

代码：

#include<stdio.h>
#include<stdlib.h>
void insertToRightPosition(int arr[],int i)
{
    int inserted = arr[i];//将需要插入的元素备份出来
    int j = i-1;
    for (; j >= 0 && arr[j] > inserted; j--)
    {
        arr[j + 1] = arr[j];//如果数组最后一个元素大于需要插入的元素，就将数组最后一个元素后移，注意此数组是已排好序的数组
    }
    arr[j + 1] = inserted;//此时，则是数组最后一个元素小于需要插入的元素，那就把需要插入的元素直接放到数组的后面
}

void insertsort(int arr[],int sz)
{
    int i = 0;
    //把数组的第一个元素作为一个已排好序的集合，数组从arr[1]后面的元素都是未排好序的集合
    for (i = 1; i < sz; i++)
    {
        insertToRightPosition(arr,i);//将arr[i]插到正确位置
    }
}
void test(int arr[],int sz)
{
    for (int i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}
int main()
{
    int arr[10] = { 1, 3, 5, 4, 6, 8, 2, 9, 7, 0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    test(arr,sz);//输出数组的元素
    insertsort(arr,sz);
    test(arr, sz);
    system("pause");
    return 0;
}

运行结果：

冒泡排序的 时间复杂度 :

假如有个N个数需要排序

外层for循环需要循环n-1次，内层for循环是根据i来决定的，i=1时，循环1次，i=2时。循环2次，……,i=n-1时。循环n-1次，总共加起来就是：1+2+3+……+（n-1）= (n(n-1)) / 2 = n^2 / 2 - n / 2

故时间复杂度为 O(N^2)