排序算法

一、插入排序

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);//归并左、右两边的有序序列

    }

}

 各种排序算法的比较