几种排序算法的实现与比较(c++容器)

1、插入排序

Description:使用插入排序将容器内数进行排序
Idea:
1.从容器中取数，每次都把取到的数插入到正确到位置。

Q&A:

1.Q：当拿到一个数a时，如何将这个数插入到正确的位置？

   A：将a与已经插入到所有数进行比较，找到第一个比a大到数位置，在这个数到前面插入之；
2.Q：如何判断已经排完序，即结束条件是什么？
   A：当所有到数都插入时，即取数数组到元素为空，即结束，可以设置一个计数器count；
Input:未排序的数组
Output:字典排序的数组
Data Structure:使用容器存放数组，利用迭代器进行遍历，函数传递迭代器，返回排好序容器到迭代器；
Complexity：O(n^2)

实现代码（分传递迭代器与传递容器两种）：

//传递迭代器
void insert_sort(iter first, iter last)
{
    int flag = 0;
    int tem = 0;
    iter it;
    for(iter i = first+1;i != last;i++)
    {
        flag = 0;
        tem  = *i;
        for(iter j = first;j != i;j++)
        {
            if(*i > *j)flag++;
            else 
            {
                it = first+flag;
                copy_backward(it,i,i+1);
                *(it) = tem;
            }
        }
    }
}

//传递容器
vec insert_sort(vec &array)
{
    int flag = 0;
    iter first = array.begin();
    iter it;
    int tem = 0;
    for(iter i = array.begin() + 1; i != array.end(); i++)
    {
        flag = 0;
        tem = *i;
        for(iter j = array.begin(); j !=i; j++)
        {
            if(*i > *j)
                flag++;
            else  
            {
                it = first+flag;
                copy_backward(it,i,i+1);
                *(it) = tem;
            }
        }
    }
    return array;
}

测试截图：

2、归并排序

Description: 利用归并递归到思想，进行数组到字典排序；
Idea:
1.将问题逐步细化，进行递归求解.
Q&A:
1.Q：递归终止条件是什么？
   A：当要分割的数的数目为1时;
2.Q：merge函数如何实现？
   A：函数原型：merge(iter val_it,iter res_it,int start,int first_end,int end);其中参数val为待归并到
    容器的迭代器，rel为归并后保存数据容器的迭代器，start为第一个归并集合与val间的距离，相当于
    (val+start)为归并数据的起始位置，同理(val+first_end)为第一个集合到最后一个元素，
    (val+first_end+1)为第二个集合的起始位置，(val+end)为第二个集合最后一个元素。
Input:未排序的数组
Output:字典排序的数组
Data Structure:
1.使用容器存放数组，利用迭代器进行遍历，函数传递迭代器，返回排好序容器的迭代器；
2.原始排序数组存放在value容器中，归并时到数据保存在result容器中。
Complexity：(nlogn)

实现代码：

void merge_sort(vec &v,int start,int end)
{
    if(start < end)
    {
        int mid = (start + end)/2;
        merge_sort(v,start,mid);
        merge_sort(v,mid+1,end);
        merge(v,start,mid,end);
    }
}

//按序归并两个容器
void merge(vec &v,int start,int first_end,int end)
{
    int n = first_end - start +1;
    int m = end - first_end;
    int first_count = 0,second_count = 0;
    vec v_first(n + 1);
    vec v_second(m + 1);

    copy(v.begin() + start,v.begin() + first_end + 1,v_first.begin());
    copy(v.begin() + first_end + 1,v.begin() + end + 1,v_second.begin());
    *(v_first.end()-1) = 2147483647; 
    *(v_second.end()-1) = 2147483647;

    int value_first = 0,value_second = 0;
    for(int i = 0,j = 0,k = start;k != end + 1;++k)
    {
        value_first = *(v_first.begin() + i);
        value_second = *(v_second.begin() + j);
        if(value_first < value_second)
        {
            *(v.begin() + k) = value_first;
            i++;
        }
        else if(value_first >=value_second)
        {
            *(v.begin() + k) = value_second;
            j++;
        }
    }
}

测试截图：

3、快速排序：

Description:利用快排分治的思想将n个数排序。
Idea:
1.给定一个数组，选定一个基轴，假定每次选定第一个数为基轴，则从最后一个数进行扫描，找到第一
  个小于基轴的数，并放入基轴位置，此时得到一个空位置，然后从基轴下一个位置扫描，找到第一个
  大于基轴的数。之后每次都以此方向扫描，并从上次扫描的下一位置扫描。此函数记为partition().
2.基准位置确定后，在分别在其两端再次调用partition()函数。
Q&A:
1.Q：partition函数什么时候结束?
   A：从左和从右扫描的计数器相等时结束。
Input:未排序的数组
Output:字典排序的数组
Data Structure:使用容器存放数组，利用迭代器进行遍历，函数传递迭代器，返回排好序容器到迭代器；
Complexity：O(nlogn)-O(n^2)

实现代码（扫描分从左往右和从两端向中间两种）：

void quick_sorts(iter it,int start,int end)
{
    int p = 0;
    if(start < end)
    {
        p = partitions(it,start,end);
        quick_sorts(it,start,p - 1);
        quick_sorts(it,p + 1,end);
    }
}


void quick_sort(iter it,int start,int end)
{
    int p = 0;
    if(start < end)
    {
        p = partition(it,start,end);
        quick_sort(it,start,p - 1);
        quick_sort(it,p + 1,end);
    }
}

//From left to right to scan
int partitions(iter it,int start,int end)
{
    int x = *(it+end),i = start - 1;
    for(int j = start;j < end;++j)
    {
        if(*(it + j) <= x)
        {
            ++i;
            swap_ranges(it + i,it + i + 1,it + j);
        }
    }
    swap_ranges(it + i + 1,it + i + 2,it + end);
    return i+1;
}


//From left and right to middle to scan
int partition(iter it,int start,int end)
{
    int left,right;
    int tem = 0;
    int base = *(it + start);
    int l_pos = 0,r_pos = 0,pos = 0;
    pos = start;
    for(left = start + 1,right = end,l_pos = start;left <= right;)
    {
        while(left <= right)
        {
            if(*(it + right) <= base)
            {
                *(it + l_pos) = *(it + right);
                r_pos = right;
                pos = r_pos;
                --right;
                break;
            }
            else --right;
        }
        while(left <= right)
        {
            if(*(it + left) >=base)
            {
                *(it + r_pos) = *(it + left);
                l_pos = left;
                pos = l_pos;
                ++left;
                break;
            }
            else ++left;
        }
    }
    *(it + pos) = base;
    return pos;
}

测试截图：