八大经典排序算法

 

目前常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。

根据平均时间复杂度可分为 O(n²）:          插入排序、选择排序、冒泡排序。 （冒泡和插入算法在序列正序的情况下可以进化为O(n) )

　　　　　　　　　　　　 O(nlog2(n)) :  归并排序、堆排序、快速排序。

　　　　　　　　　　　　 O(n^1.3):       希尔排序。

　　　　　　　　　　　　 O(n+k):          基数排序。

 

冒泡排序：

void bubble_sort(long a[],int n)
{
    for(int i=0;i<n-1;i++)
    {
        for(int j=0;j<n-1-i;j++)
        {
            if(a[j]>a[j+1])
            {
                long temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}

选择排序：

void select_sort(long a[],int n)
{
    for(int i=0;i<n-1;i++)
    {
        int min = a[i];
        int k=i;
        for(int j=i+1;j<n;j++){
            if(a[j]<min)
            {
                min = a[j];
                k=j;
            }
        }
        if(k!=i)
        {
            int temp = a[i];
            a[i]=a[k];
            a[k]=temp;
        }
    }
}

插入排序：

void insert_sort(long a[],int n)
{
    for(int i=1;i<n;i++)
    {
        int j=i-1;
        long temp = a[i];
        while(j>=0 && a[j]>temp)
        {
            a[j+1]=a[j];
            j--;
        }
        a[j+1] = temp;
    }
}

希尔排序：

void shell_sort(long a[],int n)
{
    int gap = 1;
    while(gap < n/3) gap = gap*3+1;
    for(gap;gap>0;gap/=2)
    {
        for(int i=gap;i<n;i++)
        {
            int temp = a[i];
            int j;
            for(j=i-gap;j>=0&&a[j]>temp;j-=gap)
            {
                a[j+gap]=a[j];
            }
            a[j+gap] = temp;
        }
    }
}

归并排序：

//运动分治递归的思想
void merge_he(long a[],int left,int mid,int right,long *temp)
{
    int i=left;
    int j=mid+1;
    int k=left;
    while(i<=mid && j<=right)
    {
        if(a[i]<a[j])
        {
            temp[k++]=a[i++];
        }
        else if(a[i]>=a[j])
        {
            temp[k++]=a[j++];
        }
    }
    while(i<=mid)
    {
        temp[k++]=a[i++];
    }
    while(j<=right)
    {
        temp[k++]=a[j++];
    }
    memcpy(a+left,temp+left,sizeof(long)*(right-left+1));
}
void merge_fen(long a[],int left,int right,long *temp)
{
    if(left < right)
    {
        int mid = left + (right - left)/2;
        merge_fen(a,left,mid,temp);
        merge_fen(a,mid+1,right,temp);
        merge_he(a,left,mid,right,temp);
    }
}
void merge_sort(long a[],int n)
{
    long *temp = (long *)malloc(sizeof(long)*n);
    merge_fen(a,0,n-1,temp);
    free(temp);
}

快速排序：

void quick(long a[],int left,int right)
{
    if(left<right)
    {
        int i=left;
        int j=right;
        long temp = a[i];
        while(i<j)
        {
            while(i<j&&a[j]>temp) j--;
            if(i<j) a[i++]=a[j];
            while(i<j&&a[i]<temp) i++;
            if(i<j) a[j--]=a[i];
        }
        a[i]=temp;
        quick(a,left,i-1);
        quick(a,i+1,right);
    }
}
void quick_sort(long a[],int n)
{
    quick(a,0,n-1);
}

堆排序：

void heap(long a[],int parent,int n)
{
    int child = 2*parent+1;
    long temp = a[parent];
    while(child < n)
    {
        if(child+1 <n && a[child] < a[child+1])
        {
            child++;
        }
        if(a[child] < temp)
            break;

        a[parent] = a[child];

        parent = child;
        child = 2*parent +1;
    }
    a[parent] = temp;
}
void heap_sort(long a[],int n)
{
    for(int i=n/2-1;i>=0;i--)
        heap(a,i,n);

    for(int i=n-1;i>0;i--)
    {
        int temp = a[0];
        a[0] = a[i];
        a[i] = temp;

        heap(a,0,i);
    }
}

基数排序：

long get_max(long a[],int n)
{
    long max = a[0];
    for(int i=1;i<n;i++)
    {
        if(a[i]>max)
            max = a[i];
    }
    return max;
}
void radix_sort(long a[],int n)
{
    long bucket[10][n];   //桶
    int count[10]={0};       //记录每个桶中存入数的个数

    long max = get_max(a,n);
    for(long i=1;max/i>0;i*=10)
    {
        for(int j=0;j<n;j++)
        {
            int num = (a[j]/i)%10;
            bucket[num][count[num]]=a[j];
            count[num]++;
        }
        int c=0;
        for(int i=0;i<10;i++)
        {
            if(count[i]!=0)
            {
                for(int j=0;j<count[i];j++)
                {
                    a[c++] = bucket[i][j];
                }
            }
            count[i]=0;
        }
    }
}