C++ 冒泡、堆排序、插入排序算法

#include <iostream>
#include <vector>
using namespace std ;

#define INFINITE 1000

template<typename T>
class Sort
{
public:
    void input(int n);
    void print() const;
    void BubbleSort();
    void InsertSort();
    void mergeSort(vector<T> v,int start,int end);
    void HeapSort(vector<T>& A, int heap_size);

    vector<T> v;

private:
    void merge(vector<T> value,int start,int mid,int end);
    int parent(int i);
    int left(int i);
    int right(int i);
    void Build_Max_Heap(vector<T>& A,int size);
    void Max_Heapify(vector<T>& A, int i, int heap_size);
};

//主菜单
void MainMenu()
{
    cout << "****************************************" << endl ;
    cout << "*         1.InsertSort                 *" << endl ;
    cout << "*                                      *" << endl ;
    cout << "*         2.BubbleSort                 *" << endl ;
    cout << "*                                      *" << endl ;
    cout << "*         3.MergeSort                  *" << endl ;
    cout << "*                                      *" << endl ;
    cout << "*         4.HeapSort                   *" << endl ;
    cout << "*                                      *" << endl ;
    cout << "*         0.Exit                       *" << endl ;
    cout << "****************************************" << endl ;
}

template<typename T>
void Sort<T>::input(int n)
{
    cout << "请输入要排列元素的个数：" ;
    cin >> n;
    cout << "请输入元素:";

    for (int i = 0;i < n;++ i)
    {
        T temp = 0;
        cin >> temp;
        v.push_back(temp);
    }

    cout << "输入完毕，请进行后续操作:" << endl;
}

template<typename T>
void Sort<T>::print() const
{
    if (!v.empty())
    {
        for (int i = 0;i < v.size();++ i)
        {
            cout << v[i] << " ";
        }
        cout << "\n";
    }
    else
    {
        cout << "please make sure the vector is not empty" << endl;
    }
}

/***************************以下代码实现冒泡排序*****************************/

template<class T>
void Sort<T>::BubbleSort()
{
    //v.resize(n);
    for (int i = v.size()-2;i>=0;-- i)
    {
        for (int j = 0;j<=i;++j)
        {
            if(v[j+1]<v[j])
            {
                int t = v[j+1];
                v[j+1]=v[j];
                v[j]=t;
            }//end if

        }//end for
    }//end for

}


/***************************以下代码实现插入排序*****************************/

template<class T>
void Sort<T>::InsertSort()
{
    for (int i = 1;i<v.size();++i)
    {
        T t = v[i];
        T j = i;
        while (j>0 && v[j-1]>t)
        {
            v[j]=v[j-1];
            --j;
        }
        v[j] = t;
    }
}

int main()
{
    MainMenu();

    Sort<float> s;


    while (true)
    {
        int nType = 0;
        cout << "请选择要排序的种类：" ;
        cin >> nType;

        if (0 == nType)
        {
            break;
        }

        int n = 0;
        s.input(n);

        switch(nType)
        {
        case 1:s.InsertSort();break;    //插入排序
        case 2:s.BubbleSort();break;    //冒泡排序
        case 3:s.mergeSort(s.v,0,s.v.size() - 1);break;        //归并排序
        case 4:s.HeapSort(s.v,s.v.size());break;

        }
        s.print();
    }

    system("pause");

    return 0;

}

/***************************以下代码实现归并排序*****************************/

template<class T>
void Sort<T>::merge(vector<T> value,int start,int mid,int end)  
{  
    int i ,j,k;  

    //申请辅助数组  
    int *array1 = new int[mid-start+2];
    int *array2 = new int[end-mid+1];

    //把a从mid分开分别赋值给数组  
    for(i=0;i<mid-start+1;i++)  
        *(array1+i)=v[start+i];  
    *(array1+i)=INFINITE;//作为哨兵  
    for(i=0;i<end-mid;i++)  
        *(array2+i)=v[i+mid+1];  
    *(array2+i)=INFINITE;  
    //有序的归并到数组a中  
    i=j=0;  
    for(k=start;k<=end;k++){  
        if(*(array1+i) > *(array2+j)){  
            v[k]=*(array2+j);  
            j++;  
        }  
        else{  
            v[k]=*(array1+i);  
            i++;  
        }  
    }  
    delete []array1;
    delete []array2;
}  

//归并排序  
template<class T>
void Sort<T>::mergeSort(vector<T> v,int start,int end)  
{  
    //int start = 0;
    int mid=(start+end)/2;  
    if(start<end){  
        //分解  
        mergeSort(v,start,mid);  
        mergeSort(v,mid+1,end);  
        //合并  
        merge(v,start,mid,end);  
    }  
}  

/***************************以下代码实现堆排序*****************************/
/*求父亲*/
template<typename T>
int Sort<T>::parent(int i)  
{  
    return (int)floor((i) / 2);  //floor函数为向下取整
}  

/*求左孩子*/
template<typename T>
int Sort<T>::left(int i)  
{  
    return (2 * i);  
}  

/*求右孩子*/
template<typename T>
int Sort<T>::right(int i)  
{  
    return (2 * i + 1);  
}
template<typename T>
void Sort<T>::Max_Heapify(vector<T>& A, int i, int heap_size)  
{  
    int l = left(i);  
    int r = right(i);  
    int largest;   

    /*找到父亲 左孩子 右孩子 之间的最大值*/
    if(l <heap_size && A[l] > A[i])  
    {  
        largest = l;  
    }  
    else  
    {  
        largest = i;  
    }  
    if(r <heap_size && A[r] > A[largest])  
    {  
        largest = r;  
    }  
    /*如果父亲不是最大的，则把父亲和两个孩子的较大值交换 */
    if(largest != i)  
    {  
        swap(A[largest],A[i]);
        /*交换之后破坏了较大孩子的堆得性质，对其进行调整*/
        Max_Heapify(A, largest, heap_size);  
    }  
}  
template<typename T>
void Sort<T>::Build_Max_Heap(vector<T>& A,int size)  
{   
    int begin = size/2 ;  // 堆顶元素  
    for(int i = begin; i >= 0; i--)  
    {  
        Max_Heapify(A, i, size);  
    }  
}  
template <typename T>
void Sort<T>::HeapSort(vector<T>& A, int heap_size)  
{  
    Build_Max_Heap(A,heap_size);  
    //建立大顶堆之后 堆顶已经是所有元素中最大的了  

    //a[0]是数组的第一个元素 a[heap_size - 1]是数组的最后一个元素  
    /*将堆顶依次和最后一个叶子节点交换 */
    for(int i = heap_size - 1; i >= 0; i--)  
    {  
        swap(A[i],A[0]);
        //交换之后破坏了堆得性质 重新调整 */
        Max_Heapify(A, 0, i);  //i 是元素个数  每交换依次元素就少一个  
    }  
}