排序算法
快速排序
C语言快速排序qsort(数组，长度，元素大小，cmp函数(*,*))//注意函数cmp的参数为指针
#include <stdio.h>
#include <stdlib.h>
#include <stdlib.h>   //qsort函数
int cmp (int a,int b)
{
    return a -b;
}
 
//0 3 2 1 4 5 6 9 8 7
int main()
{
    inta[10],i,x;
    for(i=0;i<10; i++)
    {
       scanf("%d",&a[i]);
    }
   qsort(a,10,sizeof(a[0]),cmp);
    for(i=0;i<10; i++)
    {
      printf("%d ",a[i]);
    }
    return 0;
}
自定义qsort
 
void qsort2(int a[],int l,int r){
    if(l<r){
        inti=l,j=r;
        intk=a[i];
       while(i<j){
           while(i<j&&a[j]>=k){
               j--;
            }
            a[i]=a[j];
           while(i<j&&a[i]<=k){
               i++;
            }
           a[j]=a[i];
        }
        a[i]=k;
       qsort2(a,l,i-1);
       qsort2(a,i+1,r);
    }
}
冒泡排序
void bubble(int a[],int n)
{
    int i,j;
    for(i=0;i<n-1; i++)
    {
       for(j=n-1; j>i; j--)
        {
           if(a[j]<a[j-1])
            {
               int t=a[j];
               a[j]=a[j-1];
               a[j-1]=t;
            }
        }
    }
}
归并排序
void merge(int a[],int l,int m,int r){
    inttemp[r-l+1];
    inti=l,j=m+1,k=0;
   while(i<=m&&j<=r){
       if(a[i]<a[j])temp[k++]=a[i++];
        elsetemp[k++]=a[j++];
    }
   while(i<=m){
       temp[k++]=a[i++];
    }
   while(j<=r){
       temp[k++]=a[j++];
    }
   for(i=0;i<k;i++){
       a[l+i]=temp[i];
    }
}
 
void mergeSort(int a[],int l,int r){
    if(l<r){
        intm=(l+r)/2;
       mergeSort(a,l,m);
       mergeSort(a,m+1,r);
       merge(a,l,m,r);
    }
}
选择排序
void selectSort(int a[],int n){
    int i,j;
   for(i=0;i<n;i++){
        intk=i;
       for(j=i+1;j<n;j++){
           if(a[j]>a[k]){
               k=j;
            }
           if(k!=i){
               int t=a[i];
               a[i]=a[k];
               a[k]=t;
            }
        }
    }
 
}

堆排序
#include <stdio.h>
#include <stdlib.h>
 
typedef struct heap_t{
       int *arr;         //point for an array to store heap value.
       intheapMaxIndex; //heap element max indexnumber
       intarrLength; //array length of arr
 
}Heap;
 
 
void printArr(int *p, int size)
{
       int i;
       for(i=0;i<size;i++)
       {
              printf("%d",p[i]);
       }
}
 
void maxHeapify(Heap *hp, unsigned int nodei)
{
       unsignedint l = (nodei+1) << 1 - 1;  //leftchild = 2i-1, -1 ?:arr[0..n-1]
       unsignedint r = (nodei+1) << 1 ;      //right child = 2i
       unsignedint largest = 0;
       intheapMaxI = hp->heapMaxIndex;
 
       if(l<= heapMaxI && hp->arr[l] > hp->arr[nodei])
              largest= l ;
       else
              largest= nodei ;
 
       if(r<= heapMaxI && hp->arr[r] > hp->arr[largest])
              largest= r ;
 
       if(largest!=nodei)
       {
              //exchange
              inttmp ;
              tmp= hp->arr[largest];
              hp->arr[largest]= hp->arr[nodei];
              hp->arr[nodei]= tmp;
 
              maxHeapify(hp,largest);
       }else{
              return;
       }
 
}
 
 
Heap *createHeap(int *arrp, int arrLength,Heap *heap)
{
 int i;
 heap->arr =arrp;
 heap->heapMaxIndex = arrLength-1;
 heap->arrLength = arrLength;
 
 //for an heapa[0..n-1]; a[(n/2)..n-1] all are leaves
 for(i =arrLength>>1-1; i >=0; i--)
 maxHeapify(heap,i);
 return heap;
}
 
 
void heapSort(Heap *hp)
{
       int tmp;
       int last;
       while(hp->heapMaxIndex>0)
       {
              last= hp->heapMaxIndex ;
              //exchange
              tmp= hp->arr[last];
              hp->arr[last]= hp->arr[0];
              hp->arr[0]= tmp;
              hp->heapMaxIndex-= 1;
              maxHeapify(hp,0); //make heap from root node 0 to heapMaxIndex
       }
 
}
 
int main()
{
       inta[]={15,25,32,23,1,-4,35,2,-85,42,0,12,26,56,45,12,145,17,25,21};
       printArr(a,20);
       printf("\n");
 
       Heaphpa,*phpa;
       phpa=  createHeap(a,20,&hpa);
       heapSort(phpa);
 
       printArr(a,20);
       putchar('\n');
       return 0;
}

C语言排序简介
C语言排序分为以下几类：
1、冒泡排序
2、选择排序
3、插入排序
4、希尔排序（最快）
5、堆排序
6、快速排序（常用）
一、冒泡排序
冒泡排序（从小到大），每一个值和下一个值比较，如果满足条件就交换。
如一个数组10,9,8,7,6,5,4,3,2,1.
9 8 7 6 5 4 3 2 1 10 
8 7 6 5 4 3 2 1 9 10 
7 6 5 4 3 2 1 8 9 10 
6 5 4 3 2 1 7 8 9 10 
5 4 3 2 1 6 7 8 9 10 
4 3 2 1 5 6 7 8 9 10 
3 2 1 4 5 6 7 8 9 10 
2 1 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 9 10 
 
每一次排序把最大的像鱼泡一样吧最大值冒到最左边
程序如下：
#include <stdio.h>
 
void swap(int a[],int i,int j)//交换函数
{
int temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
 
void print(int a[])//打印函数
{
int i;
for(i = 0 ;i < 10;i++)
{
printf("%d ",a[i]);
}
printf("\n");
}
 
void maopao(int a[])//冒泡排序
{
int i,j;
for (i = 0; i < 9; ++i)
{
for(j = 0; j < 9 - i;j++)
{
if (a[j] > a[j+1])
{
swap(a,j,j+1);
}
}
print(a);

}
    printf("\n");
}
 
 
 
int main()
{
int a[10] = {10,9,8,7,6,5,4,3,2,1};
maopao(a);
print(a);
 
    return 0;
}

C语言排序（冒泡排序、选择排序、插入排序和快速排序）
C语言排序
什么是排序？
1.冒泡排序
基本思想
主要思路：
demo
2.选择排序
基本思想
主要思路
demo
3.插入排序
基本思想
主要思路
demo
4.快速排序
基本思想
主要思路
demo

C语言排序
什么是排序？
就是将无序的变成有序的
1.冒泡排序
基本思想
在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。每一趟排序后的效果都是讲没有沉下去的元素给沉下去。
主要思路：
1.比较相邻的元素。如果第一个比第二个大，就交换它们两个。

2.对每一个相邻元素做同样的工作，从开始第一对到结尾的每一对。在这一 点，最后的元素应该会是最大的数。

3.针对多有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，知道没有任何一对数字需要比较。
demo
#include <stdio.h>

//冒泡排序
void BubbleSort(int arry[],int len)
{
        int i;
        int j;
        int temp;
        for(i=0;i<len-1;i++)//比较次数
        {
                for(j=0;j<len-1-i;j++)//比较过程
                {
                        if(arry[j]>arry[j+1]) //比较大小
                        {
                                temp=arry[j];
                                arry[j]=arry[j+1];
                                arry[j+1]=temp;

                        }
                }

        }

}
//输出
void print(int arry[],int len)
{
        int i;
        for(i=0;i<len;i++)
        {
                printf("%d ",arry[i]);
        }
}
int main()
{

        int arry[10]={9,3,56,44,77,88,54,79,52,111};

        BubbleSort(arry,10);
        print(arry,10);
        printf("\n");

        return 0;
}


2.选择排序
基本思想
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
主要思路
每一次从无序组的数据元素中选出最小的一个元素，存放在无序组的起始位置，无需组的元素减少，有序组的元素增加，直到全部待排序的数据元素排完。
demo
#include <stdio.h>

//选择排序
void selectSort(int arry[], int len)
{       int i;
        int j;
        for ( i = 0; i < len-1; i++)
        {
                int min = i;//假设第一个元素是最小的
                for (j = i + 1; j < len; j++)
                {
                        if (arry[j] < arry[min])
                        {
                                min = j;//保存最小元素的下标
                        }
                }
                //交换
                int temp = arry[min];
                arry[min] = arry[i];
                arry[i] = temp;
        }
}
//输出
void print(int arry[], int len)
{
        for (int i = 0; i < len; i++)
        {
                printf("%d ", arry[i]);
        }
}
int main()
{
        int arry[10]={15,36,26,27,24,46,44,29,52,48};
        selectSort(arry,10);
        print(arry,10);


        printf("\n");
        return 0;
}



3.插入排序
基本思想
将待排序的无序数列看成是一个仅含有一个元素的有序数列和一个无序数列，将无序数列中的元素逐次插入到有序数列中，从而获得最终的有序数列。
主要思路
插入排序是最简单常用的方法，将数组分为两部分，排好序的数列，以及未排序的数列，将未排序的数列中的元素 与排好序的数列进行比较，然后将该元素插入到已排序列的合适位置中。
demo
#include <stdio.h>

//插入排序
void insertSort(int arry[], int len)
{
        int i;
        int temp;//保存要插入的元素
        int j;//从当前要要比较插入的元素的前面一个开始
        for ( i = 1; i < len; i++)//第一个元素视为有序,把后面的元素一个一个的插入到前面
        {
                temp = arry[i];
                j = i - 1;
                while (j >= 0&&arry[j]>temp)
                {
                        arry[j + 1] = arry[j];//前面的元素往后面移动
                        j--;
                }
                arry[j + 1] = temp;//把要插入的元素,插入进对应的位置
        }
}
//输出
void print(int arry[], int len)
{
        for (int i = 0; i < len; i++)
        {
                printf("%d ", arry[i]);
        }
}
int main()
{
        int arry[10]={3,44,38,5,47,15,36,26,27,2};
        insertSort(arry,10);
        print(arry,10);


        printf("\n");
        return 0;
}



4.快速排序
基本思想
快速排序算法的基本思想为分治思想。

先从数列中取出一个数作轴值（基准数）pivot；

根据基准数将数列进行分区，小于基准数的放左边，大于基准数的放右边；

重复分区操作，知道各区间只有一个数为止。
主要思路
快速排序是找出一个元素（理论上可以随便找一个）作为基准，然后对数组进行分区操作，使基准左边元素的值都不大于基准值，基准右边的值都不小于基准值，如此作为基准的元素调整到排序后的正确位置。递归快速排序，将其他n - 1 个元素也调整到排序后的正确位置。最后每个元素都是在排序后的正确位置，排序完成。所以快速排序算法的核心算法是分区操作，及如何调整基准的位置以及调整返回基准的最终位置以便分治递归。
demo
#include <stdio.h>

//快速排序
void quickSort(int arry[], int low, int high)
{
        if (low > high)
        {
                return;
        }
        int i = low, j = high, temp = arry[i];//获取左右和基准数
        while (i < j)
        {
                while (temp < arry[j] && i < j)
                {
                        j--;
                }
                if (i < j)
                  {
                        arry[i++] = arry[j];
                  }
                while (temp>arry[i] && i < j)
                    {

                        i++;
                     }
                if (i < j)
                    {
                        arry[j--] = arry[i];
                    }
        }
        arry[i] = temp;

        quickSort(arry, low, i - 1);//左边
        quickSort(arry, i + 1, high);//右边
}
//输出
void print(int arry[], int len)
{
        for (int i = 0; i < len; i++)
        {
                printf("%d ", arry[i]);
        }
}
int main()
{

        int arry[15]={7,44,38,99,47,15,36,26,27,2,46,43,19,50,48};
        quickSort(arry,0,14);
        print(arry,15);

        printf("\n");
        return 0；
}        

C语言排序算法
1.冒泡排序
void BubbleSort(int a[],int n)
{
	int i,j,t,flag=0;//flag用来标记是否发生交换 
	for(i=0;i<n;i++)
	{
		for(j=n-1;j>i;j--)
		{
			if(a[j-1]>a[j])//交换数据 
			{
				t=a[j-1];
				a[j-1]=a[j];
				a[j]=t;
				flag=1;//有数据交换，设置标志变量 
			}
		}
		if(flag==0)//没发生交换，直接跳出循环 
		break;
		else
		flag=0;
	}
 }