数据结构1：排序

关键字相同的项排序后顺序不变就是稳定的排序算法，否则是不稳定的排序算法。

排序分为内部排序和外部排序，内部排序只需要访问内存，外部排序还需要访问外存。

1.冒泡排序（稳定排序算法）

很经典简单的方法，每个数字从最下面开始一层一层往上走，像冒泡泡一样。

冒泡是用两个嵌套的for循环实现的，基本操作（比较两个数的大小）的执行次数最差是n（n-1）/2，最好的情况下的是有序的，则执行次数是n。

因此，冒泡排序算法的时间复杂度：最差，平均：O(n²)，最好：O(n)

空间复杂度：1（原地工作）   只需要交换值，不需要额外的空间

 时间复杂度是一个量级的概念，有点类似于高数里的极限的概念，因此n（n-1）/2可以看成n平方的复杂度。

2.快速排序（不稳定排序算法）

2.1方法：快排是建立在递归的基础上的排序算法，基本思想就是将一个序列分为两部分，再分别给两部分内部排序。

2.2 特点：快排算法的特点是不用交换，直接取代，而且二分法的递归策略很大提高了快排的效率。

2.3 时间复杂度（这个我不会推导）     最好、平均：O(n log(n）)       最差：O(n²)

 2.4 空间复杂度：O（log（n））

3.堆排序

3.1 方法 堆排序分为两步，第一步是将一个序列构建成堆，第二步是依次从堆顶去除最大（小）元素，然后重新将剩下的元素构建成堆

3.2 特点 堆排序最大的特点就是时间复杂度稳定，对于数据量大的工作很适合。

3.3 时间复杂度：最差、平均、最好都是：O(n log(n）)   

3.4 空间复杂度：1（原地工作）

快排是对冒泡的改进，是将冒泡用了分治递归的策略讲一个大问题分解成若干个不相干的子问题。而堆排序是动态规划，将一个问题分解成很多个互相相关的子问题。因此堆排序更加稳定。

4.归并排序

4.1 方法 归并排序是很典型的利用递归分治策略做排序的算法，他把一个序列分为两部分，先给两部分排序然后合并。再把两部分的小序列分开分别排序在合并。这样递归操作一直到只需要排序两个数。

4.2 特点 归并排序是一个稳定的排序算法，但是比较复杂

4.3 时间复杂度：最差、平均、最好都是：O(n log(n）)   

3.4 空间复杂度：O（n）

#include <iostream>
#include<vector>
using namespace std;
//交换两个数
void swaptwo(int& var1,int& var2)
{
    int temp=var1;
    var1=var2;
    var2=temp;
}
//升序冒泡---by myself
/*
void bubblesort(vector<int>& vec)
{
    int length=vec.size()-1;
    for(int i=0;i<=length;i++)
    {
        for(int j=i+1;j<=length;j++)
        {
            if(vec[i]>vec[j])
            {
                swaptwo(vec[i],vec[j]);
            }
        }
    }
}*/
//升序冒泡---standard
void bubblesort(vector<int>& vec)
{
    int length=vec.size();
    for(int i=0;i<length-1;i++)//选定i作为要冒泡的数字，n个数只需要对n-1个数进行冒泡
    {
        for(int j=0;j<length-i-1;j++)//冒泡的过程，每一个i要经过length-i-1个数字路径的冒泡
        {
            if(vec[j]>vec[j+1])
            swap(vec[j],vec[j+1]);
        }
    }
}
int partition(vector<int> &vec,int low,int high)//输出序列的第一个数字的正确排序的坐标
{
    int pivotkey=vec[low];//寻找第一个值的正确位置
    while(low<high)
    {
        while(low<high&&vec[high]>=pivotkey) --high;
        vec[low]=vec[high];
        while(low<high&&vec[low]<=pivotkey)  ++low;
        vec[high]=vec[low];
    }
    vec[low]=pivotkey;
    return low;
}
void Qsort(vector<int> &vec,int low,int high)//给序列分为两部分并递归每一部分排序
{
    if(low<high)
    {
        int pivotlocation=partition(vec,low,high);
        Qsort(vec,low,pivotlocation-1);
        Qsort(vec,pivotlocation+1,high);
    }
}
void quicksort(vector<int> &vec)
{
    int length=vec.size();
    //数据检查没写,输入空数据
     Qsort(vec,0,length-1);
}
void HeapAdjust(vector<int> &vec,int low,int high)//堆排序的向下筛选,构建一个大顶堆
{
    int temp=vec[low];
    for(int i=low*2;i<=high;i*=2)
    {
        if(i<high&&vec[i]<vec[i+1]) ++i;
        if(temp>vec[i]) break;//注意这里，为什么这里要用temp作比较呢？因为其实下面两句中low位置和较大的数位置是交换的关系
                            //虽然表面是覆盖可是最后是要交换的，只是暂时不知道i位置要放哪个数而已
                            //所以交换之后temp这个数值一直都在，在交换之后仍然要判断子树是否为堆
        vec[low]=vec[i];
        low=i;
    }
    vec[low]=temp;
}
void heapsort(vector<int> &vec)
{
    int length=vec.size()-1;//之前已经给vec里push一个数字了，所以要减掉这个数字
    //数据检查
    for(int i=length/2;i>=1;--i)//将一个序列构建成一个堆
        HeapAdjust(vec,i,length);
    for(int i=length;i>1;--i)
    {
        swap(vec[1],vec[i]);
        HeapAdjust(vec,1,i-1);
    }
}
void merge(vector<int> &vec,vector<int> sorted,int start,int mid,int end)//将vec以mid为分界点的两个序列合并成一个有序序列
{
    int i=start,j=mid+1,k=i;
    for(;i<=mid&&j<=end;k++)
    {
        if(vec[i]<vec[j])
            sorted[k]=vec[i++];
        else
        {
            sorted[k]=vec[j++];
        }
        
    }
    while(i<=mid)//最后面的大数字再插到后面
    {
        sorted[k++]=vec[i++];
    }
    while(j<=end)
    {
        sorted[k++]=vec[j++];
    }
    k=start;
    while(start<=end)//将sort中排序好的结果再传给vec，即可将vec排序
        vec[start++]=sorted[k++];
}
void Msort(vector<int> &vec,vector<int> sorted,int start,int end)//分开成小序列，再合并
{
    if(start<end)
    {
        int mid=(start+end)/2;
        Msort(vec,sorted,start,mid);//将前半部分变成有序
        Msort(vec,sorted,mid+1,end);//将后半部分变成有序
        merge(vec,sorted,start,mid,end);//将这两部分合并
    }
}
void mergesort(vector<int> &vec)
{
    int length=vec.size()-1;
    vector<int> aux(length+1);//这个vector用来存放排序后的结果，由此可见归并排序需要一块额外的同样大小的内存放结果
    Msort(vec,aux,0,length);
}
int main() {
    int inputdata;
    vector<int> vec;
    
    //vec.push_back(-1);//在堆排序里，下标是从1开始的，所以先随便push一个数把下标为0的位占用了。
    vec={49,38,65,97,76,13,27,49};
    /*
     do//单行数据输入
    {
        cin >> inputdata;
        vec.push_back(inputdata);
    }while(cin.get() != '
');
    */
    //bubblesort(vec);
    //quicksort(vec);
    //heapsort(vec);
    mergesort(vec);
    for(auto &w:vec)
    {
        cout<<w<<" ";
    }
    return 0;
}