C++/C实现各种排序算法（持续更新）--冒泡排序，选择排序，归并排序

2018 3 17

今日总结一下C++中的排序算法：

1冒泡排序

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。（来源百度百科）

C++实现：

#include "stdafx.h"
#include <iostream>
using namespace std;
int ha[] = {1,7,4,2,6,5,8,3};

template <typename T>
void Bubble_Sort(T *pDst,const int nLen)
{
    int cycle;
    //外层循环，控制遍历的次数（N-1(N为待排序的数组大小)）
    for (cycle=0; cycle<(nLen-1) ; cycle++)
    {
        //内层循环，每次遍历到前一次最大值之前为止
        for (int i=0; i < (nLen - 1-cycle); i++)
        {
            if (pDst[i] > pDst[i + 1])
            {
                T tTemp = pDst[i];
                pDst[i] = pDst[i + 1];
                pDst[i + 1] = tTemp;
            }
        }
    }
}

int main()
{
    //冒泡
    
    Bubble_Sort<int>(ha,8);
    for (int i = 0; i < 8; i++)
    {
        printf("%d-",ha[i]);
　　　　 getchar();
    }
36　　 return 0;
}

 2 选择排序

　　工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。

C++实现：

//升序
template <typename T>
void Select_Sort(T *pDst, const int nLen)
{
    T tTemp;
    
//遍历nLen次，每次找到最小的值，交换
    for (int i = 0; i < nLen; i++)
    {
        for (int j = i; j < nLen; j++)
        {
            if (pDst[j] <pDst[i])
            {
                 tTemp=pDst[i];
                 pDst[i] = pDst[j];
                 pDst[j] = tTemp;

            }
            else
                continue;
        }
    }

}
int main()
{
    //冒泡
    
    //Bubble_Sort<int>(ha,8);
    Select_Sort<int>(ha,8);
    for (int i = 0; i < 8; i++)
    {
        printf("%d-",ha[i]);
    }
    return 0;
}

 3 归并排序

将两个有序（同一种序）的数组合并为一个有序数组

（1）二路归并。二路归并的最好情况时间复杂度为：O(Min{sizof(a),sizeof(b)})

// ConsoleApplication4.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "atlstr.h"
#include <iostream>
#include <vector>
using namespace std;
//////
//二路归并排序。将两个表，合并成一个表的过程称为二路归并
//如：对两个y有序的数组 进行二路归并
const int a[] = {1,2,3};
const int b[] = {1,2,3,4,5,6,7};

int* Merger_Sort(const int *a,const int *b,int nLen1,int nLen2)
{
    int *pDst = new int[nLen1+nLen2];
    int k = 0;
    int i = 0;
    int j = 0;
    while (i < nLen1&&j < nLen2)
    {
        if (a[i] <= b[j])
        {
            pDst[k] = a[i];
            i++;
        }
        else
        {
            pDst[k] = b[j];
            j++;
        }
        k++;
    }
    while (i < nLen1)
    {
        pDst[k] = a[i];
        i++;
        k++;
    }
    while (j < nLen2)
    {
        pDst[k] = b[j];
        j++;
        k++;
    }
    return pDst;
}

int main()
{
    int *p = NULL;
    p = Merger_Sort(a,b,3,7);
    for (int i = 0; i <10; i++)
    {
        cout << p[i];
    }
    delete[] p;

    getchar();
    return 0;
}

 (2) 普通归并排序 ；将二路归并扩展到一般情况，将一个序列分为N组，每组都是一个有序的数组，对两两之间进行归并

// ConsoleApplication7.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
//二路归并的前提是两个结构的元素已经是有序的（同样的顺序）
int a[] = { 1,3,4,5,6 };
int b[] = { 2,3,8,9,10,18 };
void Two_MergeSort(int *pA1, int *pA2, int nA1Len, int nA2Len, int *pOut)
{
    int i = 0; int j = 0;
    int nDstPos = 0;
    while (i < nA1Len&&j < nA2Len)
    {
        if (pA1[i] > pA2[j])
        {
            //找到同一顺序的元素中较小的放入pOut中
            pOut[nDstPos++] = pA2[j++];
        }
        else
            pOut[nDstPos++] = pA1[i++];
    }
    while (i < nA1Len)
    {
        pOut[nDstPos++] = pA1[i++];
    }
    while (j<nA2Len)
    {
        pOut[nDstPos++] = pA2[j++];
    }
}

//输入的Pos指的是坐标,可以比较一下与二路归并的区别
void General_Two_MergeSort(int *pA, int nStartPos, int nMidPos, int nEndPos, int *pOut)
{
    int i = nStartPos;
    int j = nMidPos + 1;
    int k = nEndPos;
    int nDstPos = nStartPos;
    printf("对区间[%d,%d]和区间[%d,%d]进行排序
", nStartPos, nMidPos, nMidPos + 1, nEndPos);
    while (i <= nMidPos&&j <= nEndPos)
    {
        if (pA[i] > pA[j])
        {
            pOut[nDstPos++] = pA[j++];
        }
        else
        {
            pOut[nDstPos++] = pA[i++];
        }
    }
    while (i <= nMidPos)
    {
        pOut[nDstPos++] = pA[i++];
    }
    while (j <= nEndPos)
    {
        pOut[nDstPos++] = pA[j++];
    }
    for (int n = nStartPos; n <= nEndPos; n++)
    {
        pA[n] = pOut[n];
    }
    static int nCount = 0;
    printf("第%d次调用
",++nCount);
    //printf("参数分别是：StartPos:%d,MidPos:%d,EndPos:%d
", nStartPos,nMidPos,nEndPos);
    //printf("当前排序的成员有%d个，分别是：
",nEndPos-nStartPos+1);
    for (int n = nStartPos; n <= nEndPos; n++)
    {
        printf("%d ",pOut[n]);
    }
    printf("
");
    printf("
");
    printf("
");
}


//推广到更普通的归并排序
//归并排序的核心是将一串数字中的数字分成两组，先对分成的每一组进行深度归并，最后再对初始的两组进行归并
void Merge_Sort(int *pA, int nLow, int nHigh, int *pOut)
{
    if (nLow < nHigh)
    {
        int nMid = (nLow + nHigh) / 2;
        //左边递归，直到只含有一个元素
        Merge_Sort(pA, nLow, nMid, pOut);
        //右边递归，直到只含有一个元素
        Merge_Sort(pA, nMid + 1, nHigh, pOut);
        //对两个元素进行递归排序
        General_Two_MergeSort(pA, nLow, nMid, nHigh, pOut);
    }


}


int main()
{
    int c[7] = { 0 };
    int Dst[] = { 1,3,5,7,9,11,13 };
    //Two_MergeSort(a,b,5,6,c);
    Merge_Sort(Dst, 0, 6, c);
    int i = 0;
    while (i < 7)
    {
        printf("%d ", c[i++]);
    }


    getchar();
    return 0;
}