查找排序基础

#include<bits/stdc++.h>
using namespace std;

//顺序查找
void SqSearch(int a[],int n,int key)
{
    int flag=0;
    for(int i=1;i<=n;i++)
    {
        if(a[i]==key)
        {
            cout<<i<<endl;
            flag=1;
        }
    }
    if(!flag)
    {
        cout<<"没有找到"<<endl;
    }
}

//折半查找
void HalfFind(int a[],int n,int key)
{
    int low=0,high=n-1,mid;
    while(low<=high)
    {
        mid=(low+high)/2;
        if(a[mid]==key)
        {
            cout<<mid<<endl;
            break;
        }
        else if(a[mid]>key)
        {
            high=mid-1;
        }
        else
        {
            low=mid+1;
        }
    }
}

//直接插入排序
void InsertSort(int a[],int n)
{
    int j;
    for(int i=2;i<=n;i++)
    {
        if(a[i]<a[i-1])
        {
            a[0]=a[i];
            for(j=i-1;a[0]<a[j];j--)
            {
                a[j+1]=a[j];
            }
            a[j+1]=a[0];
        }
    }
}

//折半插入排序
void HalfSort(int a[],int n)
{
    int low,high,mid;
    for(int i=2;i<=n;i++)
    {
        a[0]=a[i];
        low=1;
        high=i-1;
        while(low<=high)
        {
            mid=(low+high)/2;
            if(a[mid]>a[0])
            {
                high=mid-1;
            }
            else
            {
                low=mid+1;
            }
        }
        for(int j=i-1;j>=high+1;j--)
        {
            a[j+1]=a[j];
        }
        a[high+1]=a[0];
    }
}

//希尔排序
void ShellSort(int a[],int n)
{
    for(int dk=n/2;dk>=1;dk=dk/2)
    {
        for(int i=dk+1;i<=n;i++)
        {
            if(a[i]<a[i-dk])
            {
                int j;
                a[0]=a[i];
                for(j=i-dk;j>0&&a[0]<a[j];j-=dk)
                {
                    a[j+dk]=a[j];
                }
                a[j+dk]=a[0];
            }
        }
    }
}

//冒泡排序
void BubbleSort(int a[],int n)
{
    int flag;
    for(int i=0;i<n-1;i++)
    {
        flag=0;
        for(int j=n-1;j>i;j--)
        {
            if(a[j-1]>a[j])
            {
                swap(a[j-1],a[j]);
                flag=1;
            }
        }
        if(flag==0)
           return;
    }
}

//快速排序
int Partition(int a[],int low,int high)
{
    int pivot=a[low];
    while(low<high)
    {
        while(low<high&&a[high]>=pivot)
        {
            high--;
        }
        a[low]=a[high];
        while(low<high&&a[low]<=pivot)
        {
            low++;
        }
        a[high]=a[low];
    }
    a[low]=pivot;
    return low;
}
void QuickSort(int a[],int low,int high)
{
    if(low<high)
    {
        int pivotpos=Partition(a,low,high);
        QuickSort(a,low,pivotpos-1);
        QuickSort(a,pivotpos+1,high);
    }
}

//选择排序
void SelectSort(int a[],int n)
{
    int minn;
    for(int i=0;i<n;i++)
    {
        minn=i;
        for(int j=i+1;j<n;j++)
        {
            if(a[j]<a[minn])
            {
                minn=j;
            }
        }
        if(minn!=i)
        {
            swap(a[minn],a[i]);
        }
    }
}

//归并排序
int b[100];
void Merge(int a[],int low,int mid,int high)
{
    int k;
    for(k=low;k<=high;k++)
    {
        b[k]=a[k];
    }
    int i=low,j=mid+1;
    for(k=i;i<=mid&&j<=high;k++)
    {
        if(b[i]<=b[j])
        {
            a[k]=b[i];
            i++;
        }
        else
        {
            a[k]=b[j];
            j++;
        }
    }
    while(i<=mid)
    {
        a[k++]=b[i++];
    }
    while(j<=high)
    {
        a[k++]=b[j++];
    }
}
void MergeSort(int a[],int low,int high)
{
    if(low<high)
    {
        int mid=(low+high)/2;
        MergeSort(a,low,mid);
        MergeSort(a,mid+1,high);
        Merge(a,low,mid,high);
    }
}

//堆排序
//建立大根堆
void HeadAdjust(int a[],int k,int len)
{
    a[0]=a[k];
    for(int i=2*k;i<=len;i*=2)
    {
        if(i<len&&a[i]<a[i+1])
        {
            i++;
        }
        if(a[0]>=a[i])
        {
            break;
        }
        else
        {
            a[k]=a[i];
            k=i;
        }
    }
    a[k]=a[0];
}
void BuildMaxHeap(int a[],int len)
{
    for(int i=len/2;i>0;i++)
    {
        HeadAdjust(a,i,len);
    }
}
void HeapSort(int a[],int len)
{
    BuildMaxHeap(a,len);
    for(int i=len;i>1;i--)
    {
        swap(a[i],a[1]);
        HeadAdjust(a,1,i-1);
    }
}
int main()
{
    int a[100];
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    MergeSort(a,0,n-1);
    for(int i=0;i<n;i++)
    {
        cout<<a[i]<<" ";
    }
    cout<<endl;
}