排序算法

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

#define INFINITE 1000
//主菜单
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<class T >
void Input(vector<T >& v , int num)
{
    v.resize(num);
    for (int i = 0; i < num;++ i)
    {
        cin >> v[i];
    }
    cout << endl ;
}
//输出函数
template<class T >
void print(vector<T>& v,int num)
{
    v.resize(num);
    for (int i = 0; i < num;++ i)
    {
        cout << v[i] << " ";
    }
    cout << endl ;
}

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

template<class T>
void InsertSort(vector<T>& v , int size)
{
    for (int i = 1;i<size;++i)
    {
        int t = v[i];
        int j = i;
        while (j>0 && v[j-1]>t)
        {
            v[j]=v[j-1];
            --j;
        }
        v[j] = t;
    }
}
/***************************以下代码实现冒泡排序*****************************/

template<class T>
void BubbleSort(vector<T > &v,int n)
{
    v.resize(n);
    for (int i = n-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;
            }

        }
    }

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

template<class T>
void merge(vector<T>& v,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 mergeSort(vector<T>& v,int start,int end)  
{  
    int mid=(start+end)/2;  
    if(start<end){  
        //分解  
        mergeSort(v,start,mid);  
        mergeSort(v,mid+1,end);  
        //合并  
        merge(v,start,mid,end);  
    }  
}  

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

/*求左孩子*/ 
int left(int i)  
{  
    return (2 * i);  
}  

/*求右孩子*/ 
int right(int i)  
{  
    return (2 * i + 1);  
} 

void Max_Heapify(vector<int>& 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);  
    }  
}  
void Build_Max_Heap(vector<int>& A,int size)  
{   
    int begin = size/2 ;  // 堆顶元素  
    for(int i = begin; i >= 0; i--)  
    {  
        Max_Heapify(A, i, size);  
    }  
}  
void HeapSort(vector<int>& 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 是元素个数  每交换依次元素就少一个  
    }  
} 

int main()
{
    MainMenu();
    vector<int> v ;
    int num  = 0;
    while (1)
    {
        int menu;
        cout << "Choice the method of sorting:";
        cin >> menu;
        cout << endl;
        if (menu == 0)
        {
            cout << "退出系统" << endl ;
            break;
        }
        cout << "Input the num of element will be sorted:";
        cin >> num ;
        cout << endl;
        cout<<"The origin array:";
        Input(v,num);
        cout << "before sorted:";
        print(v,num);    
        switch (menu)
        {
        case 1:
            InsertSort(v,num);
            break;
        case 2:
            BubbleSort(v,num);
            break;
        case 3:
            mergeSort(v,0,num-1);
            break;
        case 4:
            HeapSort(v,num);
            break;
        default:
            break;
        }
        cout << endl ;
        cout << "after sorted:";
        print(v,num);
        cout<<endl;

    }
    system("pause");
    return 0;
}