常用排序算法的c++实现

闲来没事手打了一遍几种排序算法，分享以供大家参考：

#include<iostream>
using namespace std;
//交换数组中2个元素的值
void swap(int &a, int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
}
//冒泡排序最简单的暴力解法
void bubble_sort(int a[], int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 1; j < n - i; j++)
        {
            if (a[j - 1]>a[j])
                swap(a[j - 1], a[j]);
        }
    }
}
//增加一个flag的冒泡排序，一旦本次遍历未发生交换，那就是排好了
void bubble_sort1(int *a, int n)
{
    bool flag = false;

    for (int i = 0; i < n; i++)
    {
        flag = true;
        for (int j = 1; j < n - i; j++)
        {
            if (a[j - 1]>a[j])
            {
                swap(a[j - 1], a[j]);
                flag = false;
            }
        }
        if (flag)
            break;
    }

}
//同上，增加一个flag的冒泡排序，一旦本次遍历未发生交换，那就是排好，只不过外部采用while循环嵌套
void bubble_sort2(int *a, int n)
{
    int k = n;
    bool flag = false;
    while (!flag)
    {
        flag = true;
        for (int i = 1; i < k; i++)
        {
            if (a[i - 1]>a[i])
            {
                swap(a[i - 1], a[i]);
                flag = false;
            }
        }
        k--;
    }
}
//改进的冒泡排序，记录下上一次遍历最后交换的位置，也就是这个位置之后的位置上的元素都有序了（每排一次，最大的“沉底”）
//这样，下一次遍历就从开始，遍历到这个位置即可
void bubble_sort3(int *a, int n)
{
    int tmp = n;
    int k = n;
    while (tmp>0)
    {
        k = tmp;
        tmp = 0;
        for (int j = 1; j <k; j++)
        {
            if (a[j - 1]>a[j])
            {
                swap(a[j - 1], a[j]);
                tmp = j;
            }
        }
    }
}
//归并排序所使用的函数，功能是使两个有序数组合为一个，时间复杂度为n
//过程：每次从俩数组尾部取出一个小的放到temp[]中
void mmergearray(int a[], int left,int  mid,int  right,int tmp[])
{
    int i = left, j = mid+1;
    int k = 0;
    int m = mid, n = right;
    while (i<=m &&j<=n)
    {
        if (a[i]<=a[j])
        {
            tmp[k] = a[i];
            i++;
            k++;
        }
        else
        {
            tmp[k] = a[j];
            j++;
            k++;
        }
    }
    while(i<=m)
    {
        tmp[k] = a[i];
        i++;
        k++;
    }
    while (j <= n)
    {
        tmp[k] = a[j];
        j++;
        k++;
    }
    for (int i = 0; i < k;i++)
    {
        a[i+left] = tmp[i];
    }

}
//归并排序的实现函数
//思路是找到中值，让左边有序，右边有序，调用mmergearray接口，在o（n）时间内，合成一个整体有序的序列
void merge_sort(int a[], int left, int right,int tmp[])
{
    if (left<right)
    {   
        int mid = (left+right) / 2;
        merge_sort(a,left,mid,tmp);
        merge_sort(a, mid+1, right,tmp);
        mmergearray(a,left,mid,right,tmp);
    }
}
//归并排序的调用接口，new一个大小为n的数组指针，以便mmergearray使用
void MergeSort(int a[],int n)
{
    int *tmp = new int[n];
    if (tmp == NULL)
        cout << "error!" << endl;
    merge_sort(a, 0, n-1, tmp);
    delete[] tmp;
}
//快速排序，挖坑填数法，我这里挖的是第一个点
void quick_sort(int a[],int l,int r)
{
    if (l<r)
    {
        int i = l, j = r;
        int tmp = a[l];
        while (i<j)
        {
            while (i<j && a[j]>= tmp)
            {
                j--;
            }
            if (i < j)
            {
                a[i] = a[j];
                i++;
            }
            while (i < j && a[i] <= tmp)
            {
                i++;
            }
            if (i<j)
            {
                a[j] = a[i];
                i--;
            }
        }
        a[i] = tmp;
        //至此，对于a[i]位置上的数，左边位置的都比a[i]小，右边位置的数都比a[i]大
        quick_sort(a,l,i-1);
        quick_sort(a,i+1,r);        
    }

}
//直接插入排序，就是序列左边是有序的，右边是无序区，每次从右边拿出一个数，挨个比较，然后插入到有序区
//初始的有序区是a[0]
void insert_sort(int a[],int n)
{
    for (int i = 1; i < n;i++)
    {
        int j = i;
        int tmp = a[i];
        while (a[j-1]>tmp&& j>=1)
        {
            j--;
        }

        for (int k = i; k > j; k--)
            a[k] = a[k-1];
        a[j] = tmp;

    }


}
//选择排序，每次选择一个最大的数，放到最后面的有序区的前面
void select_sort(int a[],int n)
{
    int k = n;
    while (k>0)
    {
        for (int i = 0; i < k; i++)
        {

            if (a[i]>a[k - 1])
                swap(a[i],a[k-1]);
        }
        k--;
    }

}

//N皇后算法的实现，回溯法，使用vector模拟栈，具体见我另一篇博客：传送门

//////////////////////////////////////////////////
//八皇后问题，N皇后算法
//皇后类
#include<stack>
#include<vector>
#include<algorithm>
struct Queen
{

    unsigned int x, y;
    Queen(unsigned int xx = 0, unsigned int yy = 0) :x(xx), y(yy){};
    //
    bool operator==(const Queen& qa)const
    {
        return(x == qa.x || y == qa.y || (x + y) == (qa.x + qa.y) || (x - y) == (qa.x - qa.y));
    }
    bool operator!=(Queen const& qa)const
    {
        return !(*this == qa);  
    }
    Queen& operator=(Queen const& qa)
    {
        x = qa.x;
        y = qa.y;
        return *this;
    }
};
void myQueens(unsigned int N)
{
    vector<Queen> solu; 
    Queen q(0, 0);
    unsigned int row = 0;
    while (row < N)
    {
        while ((q.y < N) && (solu.end() != find(solu.begin(), solu.end(), q)))//直到在本行找到一个位置或者到了行尾
        {
            q.y++;
        }
        if (N > q.y)//如果没到行尾，也就是在本行找到了一个合适的位置
        {
            solu.insert(solu.end(), q);//把此时的位置入栈
            q.x++; q.y = 0;//转到下一行的行首
            row++;
        }
        else//到了行尾
        {
            q = solu[solu.size() - 1];//把上一行的坐标再拿出来
            solu.erase(solu.end() - 1);//删除之，其实就是出栈的过程
            row--;
            q.y++;//本行当前位置不合适，继续往后找一个合适的位置
        }

    }

    for (auto i : solu)
        cout << (i).x << " " << (i).y << endl;
    cout << "ok" << endl;
}

//////////////////////////////////////////
//根据前序遍历，中序遍历，算出后序遍历
int pre[] = { 0, 1, 3, 4, 6, 2 ,5,7};
int mid[] = { 3, 1, 6, 4, 0, 2,7,5 };
void post(int root, int start, int end)
{
    if (start > end)
        return;
    int i = start;
    while (i < end && mid[i] != pre[root]) i++;  //定位根在中序的位置
    post(root + 1, start, i - 1);  //递归处理左子树
    post(root + 1 + i - start, i + 1, end);  //递归处理右子树
    //cout<<pre[root];  //访问当前树的根
    cout << mid[i];
}

///////////////////////////////////////////
int main()
{
    int a[] = {10,9,8,7,6,5,3,4,2,2,1,0};
    int n = 12;
    //下面是函数接口，去掉注释即可测试
    //bubble_sort3(a,n);
    //MergeSort(a,n);
    //quick_sort(a,0,n-1);
    //insert_sort(a,n);
    //select_sort(a,n);
    //myQueens(8);
    //for (int i = 0; i < 12; i++)
        //cout << a[i] << "  ";
    //post(0,0,7);
    system("pause");
    return 0;
}