排序算法

一、插入排序

1、直接插入排序

//直接插入排序
template<class T>
void insertSort(T array[],int n)
{
    T temp;
    for(int i = 1; i < n ; i++)//循环，i表示插入的趟数，共进行n-1趟插入
    {
        temp = array[i];//将待插入元素赋给temp
        int j = i-1;
        while(j >= 0 && temp < array[j])//把比temp大的元素向后移
        {
            array[j+1] = array[j];
            j--;
        }
        array[j+1] = temp;//j+1为temp的位置，将temp插入到这个位置
    }
}

利用有序表的插入操作，即将第p+1个元素插入到前面的p个元素中，插入位置后的元素进行后移。

2、折半插入排序

//折半插入排序

template<class T>
void BianryInsertSort(T array[],int n){
    for(int i = 1; i < n; i++)//共进行n-1次插入
    {
       int left = 0, right = i-1, mid;
       T  temp = array[i];//保存待插入数据
       while(left <= right)
       {
           mid = (left + right)/2;//求出中心点
           if(temp < array[mid])//如果待插入数据比中心点元素小
           {
               right = mid - 1;//更新右区间的值
           }
           else
               left = mid + 1;//更新左区间的值
       }
for(int j = i-1;j >= left; j--)//执行移动操作
           array[j+1] = array[j];
       array[left] = temp;//将待插入数据插入到有序表中
    }
}

3、希尔排序

//希尔排序（不稳定）

template<class T>
void ShellSort(T array[], int n){
    int d = n/2;//增量初始化为数组大小的一半
    while(d>=1)//循环遍历所有可能
    {
        for(int k = 0; k<d; k++)//遍历所有的子序列
        {
            for(int i=k+d; i<n; i+=d)//对每一个子序列执行插入排序
            {
                T temp = array[i];
                int j = i-d;
                while(j>=k && array[j] > temp){
                    array[j+d] = array[j];
                    j-=d;
                }
                array[j+d] = temp;
            }
        }
        d = d/2;//增量为上次的一半
    }
}

二、交换排序

1、冒泡排序

template<class T>
void BubbleSort(T array[], int n)
{
    for(int i = 0; i < n; i++)//外层循环控制排序的每一趟
    {
        for(int j = 1; j < n-i; j++)//内层循环控制本趟中的冒泡操作
        {
            if(array[j] < array[j-1])//如果是逆序的，则交换这两个元素
            {
                T temp = array[j];
                array[j] = array[j-1];
                array[j-1] = temp;
            }
        }
    }
}

 2、改进的冒泡排序

template<class T>
void BubbleSort2(T array[],int n)
{
    int flag = 0;//标记每一趟的冒泡排序过程中是否发生了交换
    for(int i = 0; i < n; i++)//外层循环控制排序的每一趟
    {
        flag = 0;
        for(int j = 0; j < n-i; j++)//内层循环控制本趟中的冒泡排序
        {
            if(array[j] < array[j-1])
            {
                flag = 1;
                T temp = array[j];
                array[j] = array[j-1];
                array[j-1] = temp;
            }
        }
        if(flag == 0)//如果某一趟的冒泡过程中没有发生交换则结束操作
               return;
    }

}

 四、选择排序

1、简单选择排序

void SelectSort(int array[],int n)
{
    for(int i = 1; i < n; i++)
    {
        int k = i-1;
        for(int j = i; j < n; j++)
        {
            if( array[j] < array[k] )
            {
                k = j;
            }
            if( k!= i-1)
            swap(array[k],array[i-1]);
        }
    }
}

利用线性查找的方法从一个序列中找到最小的元素

2、堆排序（不稳定）

template<class T>
void SiftDown(T array[], int i, int n)
{   //用来保持以结点i为根的最大堆的性质，n是所有元素的个数
    int l = 2*i + 1, r = 2*i + 2, min = i;//找到i结点的两个孩子的下标
    if(l < n && array[min] < array[l])//和左子结点进行比较
       min = l;
    if(r < n && array[min] < array[r])//和右子结点进行比较
       min = r;
    if(min != i)//判断是否进行调整
    {
        swap(array[min],array[i]);
        SiftDown(array,min,n);//递归对子结点进行调整
    }
}
template<class T>
void BuildHeap(T array[], int n)//创建一个最大堆
{
    int p = n/2 - 1;//求出非叶子结点的最大下标
    for(int i = p;i >= 0; i--)
    {
        SiftDown(array,i,n);
    }
}
template<class T>
void HeapSort(T array[],int n)
{
    BuildHeap(array,n);//首先建立一个最大堆
    for(int i = n-1; i > 0; i--)
    {
        swap(array[0],array[i]);
        BuildHeap(array,i);
    }
}

利用最大堆找到序列中的最大值，将 堆顶元素和当前最后一个元素进行交换，n = n-1；

五、归并排序

template<class T>
//归并函数
void Merge(T Data[],int start,int mid,int end)
{
    int len1 = mid - start + 1,len2 = end - mid;//分别表示两个归并区间的长度
    int i,j,k;
    T* left = new T[len1]; //临时数组用来存放Data[start,mid]数据
    T* right = new T[len2];//临时数组用来存放Data[mid+1,end];
    for(i = 0;i < len1; i++)//执行数据复制操作
       left[i] = Data[i+start];
    for(i = 0;i < len2; i++)//执行数据复制操作
       right[i] = Data[i+mid+1];
    i = 0,j = 0;
    for(k = start;k < end; k++)//执行归并
    {
        if( i == len1 || j == len2)
            break;
        if( left[i] <= right[j])
           Data[k] = left[i++];
        else
           Data[k] = right[j++];
    }
    while(i < len1)//若Data[start,mid]还有待归并数据，则放到Data后面
       Data[k++] = left[i++];
    while(j < len2)//对Data[mid+1,end]间的数据执行同样的操作
       Data[k++] = right[j++];
    delete[] left;//释放内存
    delete[] right;
}
template<class T>
void MergeSort(T Data[],int start,int end)
{//对Data[start]-Data[end]之间的序列进行归并排序
    if(start < end)
    {
        int mid = (start + end)/2;//计算中间位置
        MergeSort(Data,start,mid);//对左边子序列归并排序
        MergeSort(Data,mid+1,end);//对右边子序列归并排序
        Merge(Data,start,mid,end);//归并左、右两边的有序序列
    }
}

 各种排序算法的比较