排序算法

冒泡排序：相邻元素比较，满足条件就交换元素

#include <stdio.h>
void PrintArray(int *arr,int len)
{
    int i=0;
    for(i=0;i<len;i++)
    {
        printf("%d ",arr[i]);
    }
}
//冒泡排序:相邻元素比较,是一个稳定的排序算法
void BubbleSort(int *arr,int len)
{
    int i=0,j=0;
    int temp=0;
    int flag=1;//0代表排好序,1代表没排好序了
    for(i=0;i<len&&flag==1;i++)
    {
        flag=0;//先认为排好
        for(j=1;j<len-i;j++)
        {
            if(arr[j-1]>arr[j])
            {
                temp=arr[j-1];
                arr[j-1]=arr[j];
                arr[j]=temp;
                flag=1;//1表示还没排好
            }
        }
    }
}
int main()
{
    int a[]={256,1,4,6,9,2,56,34,23,12,0,45,345,44};
    int n=sizeof(a)/sizeof(a[0]);
    int con[256]={0};
    BubbleSort(a,n);
    PrintArray(a,sizeof(a)/sizeof(a[0]));
    return 0;
}

 选择排序：与每个元素比较，满足条件就交换

#include <stdio.h>
void PrintArray(int *arr,int len)
{
    int i=0;
    for(i=0;i<len;i++)
    {
        printf("%d ",arr[i]);
    }
}
void SelectSort(int *arr,int len)
{
    int i=0,j=0;
    int temp=0;
    for(i=0;i<len;i++)
    {
        for(j=i+1;j<len;j++)
        {
            if(arr[i]>arr[j])
            {
                temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
        }
    }
}
int main()
{
    int a[]={256,1,4,6,9,2,56,34,23,12,0,45,345,44};
    int n=sizeof(a)/sizeof(a[0]);
    int con[256]={0};
    SelectSort(a,n);
    PrintArray(a,sizeof(a)/sizeof(a[0]));
    return 0;
}

插入排序：将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

#include <stdio.h>
void PrintArray(int *arr,int len)
{
    int i=0;
    for(i=0;i<len;i++)
    {
        printf("%d ",arr[i]);
    }
}
void InsertSort(int *arr,int len)
{
    int i=0,j=0;
    int tmp=0;
    for(i=1;i<len;i++)
    {
        tmp=arr[i];//拿出值
        for(j=i-1;j>=0&&tmp<arr[j];j--)//如果满足条件，则移动元素
        {
            arr[j+1]=arr[j];
        }
        arr[j+1]=tmp;//将值插入
    }
}
int main()
{
    int a[]={256,1,4,6,9,2,56,34,23,12,0,45,345,44};
    int n=sizeof(a)/sizeof(a[0]);
    int con[256]={0};
    InsertSort(a,n);
    PrintArray(a,sizeof(a)/sizeof(a[0]));
    return 0;
}

希尔排序：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

#include <stdio.h>
void PrintArray(int *arr,int len)
{
    int i=0;
    for(i=0;i<len;i++)
    {
        printf("%d ",arr[i]);
    }
}
void ShellSort(int *arr,int len)
{
    int i=0,j=0;
    int temp=0;
    int gap=len;
    do
    {
        gap=gap/3+1;//增量
        for(i=gap;i<len;i++)
        {
            temp=arr[i];//拿出值
            for(j=i-gap;j>=0&&temp<arr[j];j-=gap)
            {
                arr[j+gap]=arr[j];
            }
            arr[j+gap]=temp;
        }
    }while(gap>1);
}
int main()
{
    int a[]={256,1,4,6,9,2,56,34,23,12,0,45,345,44};
    int n=sizeof(a)/sizeof(a[0]);
    int con[256]={0};
    ShellSort(a,n);
    PrintArray(a,sizeof(a)/sizeof(a[0]));
    return 0;
}

快速排序：

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,

2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

#include <stdio.h>
void PrintArray(int *arr,int len)
{
    int i=0;
    for(i=0;i<len;i++)
    {
        printf("%d ",arr[i]);
    }
}
void QuickSort(int *arr,int left,int right)
{
    if(left<right)
    {
        int i=left;
        int j=right;
        int temp=arr[i];//基准数
        while(i<j)
        {    
            //从右向左，找比基准数大的
            while(i<j && temp<=arr[j])
            {
                j--;
            }
            if(i<j)
            {
                arr[i++]=arr[j];
            }
            //从左向右找比基准数小的
            while(i<j && temp>=arr[i])
            {
                i++;
            }
            if(i<j)
            {
                arr[j--]=arr[i];
            }
        }
        arr[i]=temp;//把基准数放入到i和j同时指向的那个坑
        QuickSort(arr,left,i-1);//排序左半部分
        QuickSort(arr,i+1,right);//排序右半部分
    }
}
int main()
{
    int a[]={256,1,4,6,9,2,56,34,23,12,0,45,345,44};
    int n=sizeof(a)/sizeof(a[0]);
    int con[256]={0};
    QuickSort(a,0,n-1);
    PrintArray(a,sizeof(a)/sizeof(a[0]));
    return 0;
}

归并排序：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

#include <stdio.h>
void PrintArray(int *arr,int len)
{
    int i=0;
    for(i=0;i<len;i++)
    {
        printf("%d ",arr[i]);
    }
}
//归并两个有序序列
void Merge(int* arr,int left,int right,int mid,int* temp)
{
    int iStart=left;
    int iEnd=mid;
    int jStart=mid+1;
    int jEnd=right;
    int len=0;
    while(iStart<=iEnd&&jStart<=jEnd)
    {
        if(arr[iStart]<arr[jStart])
        {
            temp[len++]=arr[iStart++];
        }
        else
        {
            temp[len++]=arr[jStart++];
        }
    }
    //之后有一个序列没到边界
    while(iStart<iEnd)
    {
        temp[len++]=arr[iStart++];
    }
    while(jStart<jEnd)
    {
        temp[len++]=arr[jStart++];
    }
    return ;
}
//归并排序
void MergeSort(int* arr,int left,int right,int* temp)
{
    int mid=0;
    if(left<right)
    {
        mid=(left+right)/2;
        MergeSort(arr,left,mid,temp);
        MergeSort(arr,mid+1,right,temp);
        Merge(arr,left,right,mid,temp);
    }
    return ;    
}
int main()
{
    int a[]={256,1,4,6,9,2,56,34,23,12,0,45,345,44};
    int n=sizeof(a)/sizeof(a[0]);
    int con[256]={0};
    QuickSort(a,0,n-1);
    MergeSort(a,0,n-1,con);
    PrintArray(a,sizeof(a)/sizeof(a[0]));
    return 0;
}

排序算法总结