1、冒泡法

void Sort(int *pData,int count)
{
	int temp;
	int i,j;
	for(i=0;i<count;i++)
	{
		for(j=0;j<count-i-1;j++)
		{
           if(pData[j]>pData[j+1])
			{
			   temp=pData[j];
			   pData[j]=pData[j+1];
			   pData[j+1]=temp;
		    }
		}
	}
}


int main()
{
	int data[]={10,9,8,7,6,5,4}; 
	Sort(data,7);
	int i;
	for(i=0;i<7;i++)
	{
		printf("%d\t",data[i]);
	}
	printf("\n");
	return 0;
}

2、交換法 每次用當前的元素一一的同其后的元素

void Sort(int *pData,int count)
{
	int temp;
	int i,j;
	for(i=0;i<count;i++)
	{
		for(j=i+1;j<count;j++)
		{
			if(pData[j]<pData[i])
			{
				temp=pData[i];
				pData[i]=pData[j];
				pData[j]=temp;
			}
		}
	}
}

int main()
{
	int data[]={10,9,8,7,6,5,3};
	Sort(data,7);
	int i;
	for(i=0;i<7;i++)
	{
		printf("%d\t",data[i]);
	}
	printf("\n");
	return 0;
}

3、選擇法 從數(shù)據(jù)中選擇最小的同第一個值交換，在從剩下的部分中選擇最小的與第二個交換，這樣往復下去

void Sort(int * pData,int count)
{
	int temp;
	int pos;
	int i,j;
	for(i=0;i<count;i++)
	{
		temp=pData[i];
		pos=i;
		for(j=i+1;j<count;j++)
		{
			if(pData[j]<temp)
			{
				temp=pData[j];
				pos=j;
			}
		}
		pData[pos]=pData[i];
		pData[i]=temp;
	}
}

int main()
{
	int data[]={10,11,23,65,78,3,5};
	Sort(data,7);
	int i;
	for(i=0;i<7;i++)
	{
		printf("%d\t",data[i]);
	}
	printf("\n");
	return 0;
}

4、插入法
在前面的數(shù)中尋找相應的位置插入，
然后繼續(xù)下一張
插入排序就是每一步都將一個待排數(shù)據(jù)按其大小插入到已經(jīng)排序的數(shù)據(jù)中的適當位置，直到全部插入完畢。

void Sort(int * pData,int count)
{
	int temp;
	int pos;
	int i,j;
	for(i=0;i<count;i++)
	{
		temp=pData[i];
		pos=i-1;
		while((pos>=0)&&(temp<pData[pos]))
		{
			pData[pos+1]=pData[pos];
			pos--;
		}
		pData[pos+1]=temp;
	}
}

int main()
{
	int data[]={99,34,54,23,12,76};
	Sort(data,6);
	int i;
	for(i=0;i<6;i++)
	{
		printf("%d\t",data[i]);
	}
	printf("\n");
	return 0;
}

5、快速排序法
快速排序是C.R.A.Hoare于1962年提出的一種劃分交換排序。它采用了一種分治的策略，通常稱其為分治法(Divide-and-ConquerMethod)。
該方法的基本思想是：
1．先從數(shù)列中取出一個數(shù)作為基準數(shù)。
2．分區(qū)過程，將比這個數(shù)大的數(shù)全放到它的右邊，小于或等于它的數(shù)全放到它的左邊。
3．再對左右區(qū)間重復第二步，直到各區(qū)間只有一個數(shù)。

雖然快速排序稱為分治法，但分治法這三個字顯然無法很好的概括快速排序的全部步驟。因此我的對快速排序作了進一步的說明：挖坑填數(shù)+分治法：
先來看實例吧，定義下面再給出（最好能用自己的話來總結(jié)定義，這樣對實現(xiàn)代碼會有幫助）。

以一個數(shù)組作為示例，取區(qū)間第一個數(shù)為基準數(shù)。
0 1 2 3 4 5 6 7 8 9
72 6 57 88 60 42 83 73 48 85

初始時，i = 0; j = 9; X = a[i] = 72

由于已經(jīng)將a[0]中的數(shù)保存到X中，可以理解成在數(shù)組a[0]上挖了個坑，可以將其它數(shù)據(jù)填充到這來。
從j開始向前找一個比X小或等于X的數(shù)。當j=8，符合條件，將a[8]挖出再填到上一個坑a[0]中。a[0]=a[8]; i++; 這樣一個坑a[0]就被搞定了，但又形成了一個新坑a[8]，這怎么辦了？簡單，再找數(shù)字來填a[8]這個坑。這次從i開始向后找一個大于X的數(shù)，當i=3，符合條件，將a[3]挖出再填到上一個坑中a[8]=a[3]; j–;

數(shù)組變?yōu)椋?br> 0 1 2 3 4 5 6 7 8 9
48 6 57 88 60 42 83 73 88 85

i = 3; j = 7; X=72

再重復上面的步驟，先從后向前找，再從前向后找。
從j開始向前找，當j=5，符合條件，將a[5]挖出填到上一個坑中，a[3] = a[5]; i++;
從i開始向后找，當i=5時，由于i==j退出。
此時，i = j = 5，而a[5]剛好又是上次挖的坑，因此將X填入a[5]。

數(shù)組變?yōu)椋?br> 0 1 2 3 4 5 6 7 8 9
48 6 57 42 60 72 83 73 88 85

可以看出a[5]前面的數(shù)字都小于它，a[5]后面的數(shù)字都大于它。因此再對a[0…4]和a[6…9]這二個子區(qū)間重復上述步驟就可以了。

對挖坑填數(shù)進行總結(jié)
1．i =L; j = R; 將基準數(shù)挖出形成第一個坑a[i]。
2．j–由后向前找比它小的數(shù)，找到后挖出此數(shù)填前一個坑a[i]中。
3．i++由前向后找比它大的數(shù)，找到后也挖出此數(shù)填到前一個坑a[j]中。
4．再重復執(zhí)行2，3二步，直到i==j，將基準數(shù)填入a[i]中。
代碼實現(xiàn)如下：

#include<stdio.h>
int partition(int a[],int left,int right)
{
   int x=a[left];
   while(left<right)
   	{
   	    while(right>left && a[right]>x)
   	    	{
   	    	   right--;
   	    	}
	   if(left<right)
	   	{
	   	   a[left]=a[right];
		   left++;
	   	}
	   while(left<right && a[left]<x)
	   	{ 
	   	   left++;
	   	}
	   if(left<right)
	   	{
	   	   a[right]=a[left];
		   right--;
	   	}	   	
   	}
       a[left]=x;
	return left;
}

void quikSort(int a[],int posstart,int posend)
{
     if(posstart<posend)
    	{
    	    int posmid=partition(a,posstart,posend);
            quikSort(a,posstart,posmid-1);
	        quikSort(a,posmid+1,posend);
    	}
}

void print_array(int a[],int n)
{
   int i;
   for(i=0;i<n;i++)
   	{
   	  printf("%d\t",a[i]);
   	}
   printf("\n");
}

int main()
{
  int a[] = {7, 2, 5, 6, 0, 10, 4}; 
  quikSort(a,0,sizeof(a)/sizeof(a[0])-1);
  print_array(a,sizeof(a)/sizeof(a[0]));
   return 0;
}

6、歸并排序
歸并操作的工作原理如下：
申請空間，使其大小為兩個已經(jīng)排序序列之和，該空間用來存放合并后的序列
設定兩個指針，最初位置分別為兩個已經(jīng)排序序列的起始位置
比較兩個指針所指向的元素，選擇相對小的元素放入到合并空間，并移動指針到下一位置
重復步驟3直到某一指針達到序列尾
將另一序列剩下的所有元素直接復制到合并序列尾文章來源地址http://www.zghlxwxcb.cn/news/detail-822831.html

//將有序的X[s..u]和X[u+1..v]歸并為有序的Z[s..v]   
void merge(int X[],int Z[],int s,int u,int v)
{
    int i, j, q;
	i = s;
	j = u + 1;
	q = s;
	while (i <= u && j <= v)
	{
		if (X[i] <= X[j])
		{
			Z[q++] = X[i++];
		}
		else
		{
		    Z[q++] = X[j++];
		}
	}
    while (i <= u)    //將X中剩余元素X[i..u]復制到Z   

    {
		Z[q++] = X[i++];
    }
	while (j <= v)     //將X中剩余元素X[j..v]復制到Z   

	{
		Z[q++] = X[j++];
	}
}

void mergePass(int X[], int Y[], int n, int t)  
{  
    int i = 0, j;  
    while( n - i >= 2 * t )     //將相鄰的兩個長度為t的各自有序的子序列合并成一個長度為2t的子序列   
    {  
       merge(X, Y, i, i + t - 1, i + 2 * t - 1);  
        i = i + 2 * t;  
    }  
  
    if( n - i > t )       //若最后剩下的元素個數(shù)大于一個子序列的長度t時   
        merge(X, Y, i, i + t - 1, n - 1);  
    else             //n-i <= t時，相當于只是把X[i..n-1]序列中的數(shù)據(jù)賦值給Y[i..n-1]   
        for( j = i ; j < n ; ++j )  
            Y[j] = X[j];  
}  
 
void mergeSort(int X[], int n)  
{  
    int t = 1;  
    int *Y = (int *)malloc(sizeof(int) * n);  
   while( t < n )  
    {  
       mergePass(X, Y, n, t);  
        t *= 2;  
       mergePass(Y, X, n, t);  
        t *= 2;  
   }  
    free(Y);  
}  
  
void print_array(int array[], int n)  
{  
    int i;  
    for( i = 0 ; i < n ; ++i )  
        printf("%d ", array[i]);  
    printf("\n");  
}  
 
int main()  
{  
    int array[] = {65, 2, 6, 1, 90, 78, 105, 67, 35, 23, 3, 88, -22};  
    int size = sizeof(array) / sizeof(int);  
    mergeSort(array, size);  
    print_array(array, size);  
    return 0;  
}  

到了這里，關(guān)于C語言實現(xiàn)排序算法的六種方式的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！