i3geek.com
闫庚哲的个人博客

C语言实现排序的八种方法

(1)冒泡法

冒泡法大家都较熟悉。其原理为从a[0]开始,依次将其和后面的元素比较,若a[0]>a[i],则交换它们,一直比较到a[n]。同理对a[1],a[2],…a[n-1]处理,即完成排序。下面列出其代码:

void bubble(int *a,int n) /*定义两个参数:数组首地址与数组大小*/ 
{ 
	int i,j,temp; 
	for(i=0;i<n-1;i++) 
		for(j=i+1;j<n;j++) /*注意循环的上下限*/ 
			if(a[i]>a[j]) { 
				temp=a[i]; 
				a[i]=a[j]; 
				a[j]=temp; 
			} 
}

冒泡法原理简单,但其缺点是交换次数多,效率低。

下面介绍一种源自冒泡法但更有效率的方法“选择法”。

(2)选择法

选择法循环过程与冒泡法一致,它还定义了记号k=i,然后依次把a[k]同后面元素比较,若a[k]>a[j],则使k=j.最后看看k=i是否还成立,不成立则交换a[k],a[i],这样就比冒泡法省下许多无用的交换,提高了效率。

void choise(int *a,int n) 
{ 
	int i,j,k,temp; 
	for(i=0;i<n-1;i++) { 
		k=i; /*给记号赋值*/ 
		for(j=i+1;j<n;j++) 
			if(a[k]>a[j]) k=j; /*是k总是指向最小元素*/ 
		if(i!=k) { /*当k!=i是才交换,否则a[i]即为最小*/ 
			temp=a[i]; 
			a[i]=a[k]; 
			a[k]=temp; 
		} 
	} 
}

选择法比冒泡法效率更高,但说到高效率,非“快速法”莫属,现在就让我们来了解它。

(3)快速法

快速法定义了三个参数,(数组首地址*a,要排序数组起始元素下标i,要排序数组结束元素下标j). 它首先选一个数组元素(一般为a[(i+j)/2],即中间元素)作为参照,把比它小的元素放到它的左边,比它大的放在右边。然后运用递归,在将它左,右两个子数组排序,最后完成整个数组的排序。下面分析其代码:

void quick(int *a,int i,int j) 
{ 
	int m,n,temp; 
	int k; 
	m=i; 
	n=j; 
	k=a[(i+j)/2]; /*选取的参照*/ 
	do {
		while(a[m]<k&&m<j) m++; /* 从左到右找比k大的元素*/ 
		while(a[n]>k&&n>i) n--; /* 从右到左找比k小的元素*/ 
		if(m<=n) { /*若找到且满足条件,则交换*/ 
			temp=a[m]; 
			a[m]=a[n]; 
			a[n]=temp; 
			m++; 
			n--; 
		} 
	}while(m<=n); 
	if(m<j) quick(a,m,j); /*运用递归*/ 
	if(n>i) quick(a,i,n); 
}

 (4)插入法

插入法是一种比较直观的排序方法。它首先把数组头两个元素排好序,再依次把后面的元素插入适当的位置。把数组元素插完也就完成了排序。

void insert(int *a,int n) 
{ 
	int i,j,temp; 
	for(i=1;i<n;i++) { 
		temp=a[i]; /*temp为要插入的元素*/ 
		j=i-1; 
		while(j>=0&&temp<a[j]) { /*从a[i-1]开始找比a[i]小的数,同时把数组元素向后移*/ 
			a[j+1]=a[j]; 
			j--; 
		} 
		a[j+1]=temp; /*插入*/ 
	} 
}

 (5)shell法

shell法是一个叫 shell 的美国人与1969年发明的。它首先把相距k(k>=1)的那几个元素排好序,再缩小k值(一般取其一半),再排序,直到k=1时完成排序。下面让我们来分析其代码:

void shell(int *a,int n) 
{ 
	int i,j,k,x; 
	k=n/2; /*间距值*/ 
	while(k>=1) {
		for(i=k;i<n;i++) { 
			x=a[i]; 
			j=i-k; 
			while(j>=0&&x<a[j]) { 
				a[j+k]=a[j]; 
				j-=k; 
			} 
			a[j+k]=x; 
		} 
		k/=2; /*缩小间距值*/ 
	}
}

 (6)堆排序法

堆排序是利用堆的特性对记录序列进行排序的一种排序方法。原文

1.堆调整算法

//堆调整算法
void HeapAdjust (HeapType &H, int s, int m)
{   // 已知 H.r[s..m]中记录的关键字除 H.r[s] 之外
    //均满足堆的特征,本函数自上而下调整 H.r[s]
    //的关键字,使 H.r[s..m] 也成为一个大顶堆
     rc = H.r[s];    // 暂存 H.r[s] 
     for ( j=2*s; j<=m; j*=2 ) { // j 初值指向左孩子
    自上而下的筛选过程;
     }
     // 自上而下的筛选过程
      if ( j<m && H.r[j].key>H.r[j+1].key )  ++j;     
             // 左/右“子树根”之间先进行相互比较
             // 令 j 指示关键字较小记录的位置
      if ( rc.key <= H.r[j].key )  break; 
           // 再作“根”和“子树根”之间的比较,
           // 若“>=”成立,则说明已找到 rc 的插
           // 入位置 s ,不需要继续往下调整

      H.r[s] = H.r[j];   s = j;    
        // 否则记录上移,尚需继续往下调整

    H.r[s] = rc;  // 将调整前的堆顶记录插入到 s  (注意插入的位置为s j=2*s)
} // HeapAdjust

2.排序算法

void HeapSort ( HeapType &H ) {
  // 对顺序表 H 进行堆排序
for ( i=H.length/2;   i>0;   --i )
     HeapAdjust ( H.r, i, H.length );    // 建小顶堆

for ( i=H.length; i>1; --i ) {
     H.r[1]←→H.r[i];           
          // 将堆顶记录和当前未经排序子序列
          //  H.r[1..i]中最后一个记录相互交换
     HeapAdjust(H.r, 1, i-1);  // 对 H.r[1] 进行筛选
}
} // HeapSort

 (7)归并排序法

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。原文

//将有二个有序数列a[first...mid]和a[mid...last]合并。
void mergearray(int a[], int first, int mid, int last, int temp[])
{
	int i = first, j = mid + 1;
	int m = mid,   n = last;
	int k = 0;
	
	while (i <= m && j <= n)
	{
		if (a[i] <= a[j])
			temp[k++] = a[i++];
		else
			temp[k++] = a[j++];
	}
	
	while (i <= m)
		temp[k++] = a[i++];
	
	while (j <= n)
		temp[k++] = a[j++];
	
	for (i = 0; i < k; i++)
		a[first + i] = temp[i];
}
void mergesort(int a[], int first, int last, int temp[])
{
	if (first < last)
	{
		int mid = (first + last) / 2;
		mergesort(a, first, mid, temp);    //左边有序
		mergesort(a, mid + 1, last, temp); //右边有序
		mergearray(a, first, mid, last, temp); //再将二个有序数列合并
	}
}

bool MergeSort(int a[], int n)
{
	int *p = new int[n];
	if (p == NULL)
		return false;
	mergesort(a, 0, n - 1, p);
	delete[] p;
	return true;
}

(8)基数排序(桶排)法

基数排序(以整形为例),将整形10进制按每位拆分,然后从低位到高位依次比较各个位。主要分为两个过程:
(1)分配,先从个位开始,根据位值(0-9)分别放到0~9号桶中(比如53,个位为3,则放入3号桶中)
(2)收集,再将放置在0~9号桶中的数据按顺序放到数组中
重复(1)(2)过程,从个位到最高位(比如32位无符号整形最大数4294967296,最高位10位)
原文
/********************************************************
*函数名称:GetNumInPos
*参数说明:num 一个整形数据
*		   pos 表示要获得的整形的第pos位数据
*说明:    找到num的从低到高的第pos位的数据
*********************************************************/
int GetNumInPos(int num,int pos)
{
	int temp = 1;
	for (int i = 0; i < pos - 1; i++)
		temp *= 10;

	return (num / temp) % 10;
}

/********************************************************
*函数名称:RadixSort
*参数说明:pDataArray 无序数组;
*		   iDataNum为无序数据个数
*说明:    基数排序
*********************************************************/
#define RADIX_10 10    //整形排序
#define KEYNUM_31 10     //关键字个数,这里为整形位数
void RadixSort(int* pDataArray, int iDataNum)
{
	int *radixArrays[RADIX_10];    //分别为0~9的序列空间
	for (int i = 0; i < 10; i++)
	{
		radixArrays[i] = (int *)malloc(sizeof(int) * (iDataNum + 1));
		radixArrays[i][0] = 0;    //index为0处记录这组数据的个数
	}
	
	for (int pos = 1; pos <= KEYNUM_31; pos++)    //从个位开始到31位
	{
		for (int i = 0; i < iDataNum; i++)    //分配过程
		{
			int num = GetNumInPos(pDataArray[i], pos);
			int index = ++radixArrays[num][0];
			radixArrays[num][index] = pDataArray[i];
		}

		for (int i = 0, j =0; i < RADIX_10; i++)    //收集
		{
			for (int k = 1; k <= radixArrays[i][0]; k++)
				pDataArray[j++] = radixArrays[i][k];
			radixArrays[i][0] = 0;    //复位
		}
	}
}

 

赞(0)
未经允许不得转载:爱上极客 » C语言实现排序的八种方法
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址