常用的6种排序C语言实现

1.冒泡排序：

思想是：依次比较数组的每一项，将最大（最小）的值往后移动，每次都把数组中当前没排序的最大（最小）值排到相对（下面程序的J后）最后。

void ballon_sort(int *arry,int len)//参数为数组地址和数组长度
{
    int i;
    int j;
    int temp;
    for(i=0;i<len;i++)
    {
       for(j=1;j<len-i;j++)
       {
         if(arry[j]<arry[j-1])
         {
            temp=arry[j];
            arry[j]=arry[j-1];
            arry[j-1]=temp;
         }
       }
    }
}

2.选择排序：

思想是:从后面选出比当前下标（下面程序对应的i）对应数组值还小(大)的值交换到前面

void sort(int *arry,int len)//参数为数组地址和数组长度
{
    int i,j;
    int temp;
    for(i=0;i<len-1;i++)
    {
      for(j=i+1;j<len;j++)
      {
         if(arry[i]>arry[j])
         {
             temp=arry[i];
             arry[i]=arry[j];
             arry[j]=temp;
         }
      }
    }
}

3.插入排序：

思想是：假定前面i个数是排好序的，从余下没排好的元素中选择一个元素（排好的下一个）来与前面排好序的比较，找到位置并插入。

void insert_sort(int *arry,int len)//参数为数组地址和数组长度
{
   int i;
   int j;
   int temp;
   for(i=0;i<len-1;i++)
   {
      for( j=i+1;j>0;j--)
      {
          if(arry[j]<arry[j-1])
          {
            temp=arry[j];
            arry[j]=arry[j-1];
            arry[j-1]=temp;
          }
      }
   }
}

4.快速排序：本程序是二分快排，尽量使每次都二分

思想是：先确定一个比较值（本程序选的是中间），然后从前面找个比他大（小），后面找个比他小（大）的，然后交换这个两个找出来的值，最终大（小）于目标值的都到了前面，小（大）于目标值的都到了后面，目标值的位置自动确定了。

void quick_sort(int *arry,int left,int right)//参数为数组，左下标，右下标
{
     int i=left-1;
     int j=right+1;
     int temp;
     int mid;
     int mid_num;
     if(left<right)//防止在递归时到了left=right时还继续
     {
        mid=arry[(i+j)/2];//中间值
        mid_num=(i+j)/2;
       while(i<j)//其实这里的停止条件是i==j,因为左右都是向中间归的
       {
         while(i<mid_num&&arry[++i]<mid);//找左边相对不满足从小到大的元素
         while(j>mid_num&&arry[--j]>mid);//同上
         printf("i=%d,j=%d\n",i,j);
         if(i!=j)
         {
         temp=arry[i];
         arry[i]=arry[j];
         arry[j]=temp;
         }
       }
       //此时已经确定了中间元素的位置，应该拆分成更小的继续确定更小的
       printf("left\n");
       quick_sort(arry,left,i-1);
       printf("right\n");
       quick_sort(arry,j+1,right);
     }
}

5.归并排序：

思想是：先将数组二分，分别排序，然后将排序好的合成一个（只要一层for循环就可以了），这样可以降低排序的循环次数。

void arry_merger(int *arry,int left,int mid,int right)
{
     //本函数的组合思想是：先生成一个临时数组，再把分开两部分按从小到大的顺序放到临时数组中去，最后把临时数组复制给原数组
     int i=left;
     int j=mid+1;
     int m=0;
     int *temp_arry=(int*)malloc(sizeof(int)*(right-left+1));
     if(temp_arry==NULL)
     {
        printf("Out of memery !\n");
        exit(-1);
     }
     while(i<=mid&&j<=right)//本while部分是把数组中的两部分数按从小到大放到临时数组中去
     {
         if(arry[i]<arry[j])
         {
            temp_arry[m++]=arry[i++];
         }else
         {
            temp_arry[m++]=arry[j++];
         }
     }
     for(i;i<=mid;i++)
     {
        temp_arry[m++]=arry[i];
     }
     for(j;j<=right;j++)
     {
        temp_arry[m++]=arry[j];
     }
     for(i=left,m=0;i<=right;i++,m++)
     {
         arry[i]=temp_arry[m];
     }
     free(temp_arry);
}
void arry_split(int *arry,int left,int right)//本函数是函数调用的入口
 {
      int mid;
      if(left<right)//进行二分，直到都分成单的
      {
         mid=(left+right)/2;
         printf("left= %d, mid= %d right = %d\n",left,mid,right);
         arry_split(arry,left,mid);//左分
         arry_split(arry,mid+1,right);//右分
         arry_merger(arry,left,mid,right);//分了之后组合
      }
}

6.堆排序：

//堆排序的主要思想是先建立堆，然后每次交换堆顶元素交换到最后，
//并且把最后的元素不算到数组内，并调整数组
void adjust(int *arry,int adjust_point,int size)
{
     int left,right,position;
     int temp;
     while(size>2*adjust_point+1)
     {
         position=adjust_point;
         left=adjust_point*2+1;
         if(left<size&&arry[position]<arry[left])
         {
             position=left;
         }
         right=left+1;
         if(right<size&&arry[position]<arry[right])
         {
             position=right;
         }
         if(position!=adjust_point)//选出最大的交换到前面
         {
             temp=arry[adjust_point];
             arry[adjust_point]=arry[position];
             arry[position]=temp;
             adjust_point=position;//改变过的堆要从新检测
         }
         else//由于后面的已经排好了，每次只要排好自己的就可以了
         {
            break;
         }
     }
}
void heap_sort(int *arry,int size)
{
    int root;
    int j;
    int temp;
    root=size/2;
    //从后向前建立堆，这样可以把最大的或最小的调整到最前面
    for(j=root-1;j>=0;j--)
    {
       adjust(arry,j,size);
    }
    j=size;
    while(j>0)
    {
       temp=arry[0];
       arry[0]=arry[j-1];
       arry[j-1]=temp;
       j--;
       adjust(arry,0,j);//调整被改变过的，从前往后调整，只要前面不动，后面一直都满足堆的条件
    }
}

加快排序速度的思想是：尽量减少第二层循环的次数。