c语言顺序比较法字符,常用C语言排序算法解析

摘 要：排序是计算机科学中最重要的研究问题之一，也是学习C语言程序设计过程中重点研究问题之一。主要介绍了顺序比较法、选择排序法、冒泡排序法、改进的冒泡排序法和直接插入排序法，并从排序算法的思想、模拟排序执行过程、实现排序的算法代码及算法性能分析4个方面进行了详细的解析，可以帮助C语言初学者轻松理解几种常用的排序算法。

关键词：C语言；排序；算法思想；数组

中图分类号：TP301.6 文献标识码：A 文章编号：16727800(2012)011005103

________________________________________

作者简介：毛广敏(1978-)，女，宿迁经贸高等职业技术学校讲师，研究方向为计算机软件。0 引言

在数据处理中，数据排序是相当重要的，它可以使数据更有条理，方便数据的处理。排序是程序设计的常见问题，解决排序问题也有多种算法，常用的算法有顺序比较排序法、选择排序法、冒泡排序法、直接插入排序法、快速排序和希尔排序法等排序算法。在学习C语言程序设计过程中排序算法也是重点研究问题之一，本文主要用C语言来描述几种常见的排序算法，以及分析实现算法的基本思路、模拟相应算法实现排序的过程及算法性能分析。文中所涉及的排序均为升序排序。

1 顺序比较排序法

1.1 算法思想

假设数组有n个元素，从第一个元素开始为第一趟，第一个元素和第二个元素开始到第n个元素按顺序作比较，如果第一个元素大于某个元素则第一个元素和该元素进行交换，第一个元素和其后的n1个元素一一进行两两比较结束后将是所有元素中的最小值。接下来第二趟从第二个元素开始逐一和其后的n2个元素两两比较，在进行n2次比较后第二个元素将是剩下n1个元素中的最小值。依次类推一直到第n1趟最后两个元素进行比较并得到第n1个元素是剩下的两个元素中的较小值。

1.2 模拟排序执行过程

假设一个整型数组有5个元素，分别为23、12、5、16、10，排序执行过程如下所示：

第一趟： 23 12 5 16 10 (第一趟比较前元素)

第一次：122351610(由于23>12 两元素交换)

第二次：523121610(由于12>5 两元素交换)

第三次：523121610(由于5

第四次：523121610(由于5

第二趟：523121610(第二趟比较前元素)

第一次：512231610(由于23>12 两元素交换)

第二次：512231610(由于12

第三次：510231612(由于12>10 两元素交换)

第三趟：510231612(第三趟比较前元素)

第一次：510162312(由于23>16 两元素交换)

第二次：510122316(由于16>12 两元素交换)

第四趟：510122316(第四趟比较前元素)

第一次：510121623(由于23>16 两元素交换)

1.3 实现顺序比较排序法核心代码

for(i=0；i

for(j=i+1；j

if(a[i]>a[j]) //如果当前趟的第一个元素大于当前元素，则进行交换

{t=a[i]；

a[i]=a[j]；

a[j]=t；}

1.4 算法性能分析

有n个元素参加排序要进行n1趟比较，第i趟要进行ni次两两比较。时间复杂度为O(n2)。顺序比较排序算法稳定，比较次数已知，但是该算法速度慢。

2 冒泡排序法

2.1 算法思想

假设数组有n个元素，第一趟从第一个元素开始依次比较两个相邻元素的值，如果前一个元素的值大于后一个元素的值则两个相邻元素进行交换，第一趟比较n1次，经过一趟排序n个元素中的最大值存放到最后一个数组元素中。第二趟从第一个元素开始到第n1个元素相邻两个元素作比较，如果前一个数大于后一个数则两个相邻的元素进行交换，经过n2次比较，这一趟中最大值放在第n1个数组元素的位置。依次类推一直到第n1趟第一个元素和第二个元素两个元素进行比较，两个元素中的较大值放在第二个数组元素的位置，较小值放在第一个数组元素的位置。

2.2 模拟排序执行过程

假设一个整型数组有5个元素，分别为23、12、5、16、10，用变量k保存最小值的下标，排序执行过程如下所示：

第一趟： 23 12 5 16 10 (第一趟比较前元素)

第一次： 12 23 5 16 10 (由于23>12 两元素交换位置)

第二次： 12 5 23 16 10 (由于23>5 两元素交换位置)

第三次： 12 5 16 23 10 (由于23>16 两元素交换位置)

第四次： 12 5 16 10 23 (由于23>10 两元素交换位置)

第二趟： 12 5 16 10 23 (第二趟比较前元素)

第一次： 5 12 16 10 23 (由于12>5 两元素交换位置)

第二次： 5 12 16 10 23 (由于12

第三次： 5 12 10 16 23 (由于16>10 两元素交换位置)

第三趟： 5 12 10 16 23 (第三趟比较前元素)

第一次： 5 12 10 16 23 (由于5

第二次： 5 10 12 16 23 (由于12>10 两元素交换位置)

第四趟： 5 10 12 16 23 (第四趟比较前元素)

第一次： 5 10 12 16 23 (由于5

2.3 实现冒泡排序法核心代码

for(i=0；i

for(j=0；j

if(a[j]>a[j+1]) //相邻元素比较，前者大于后者则交换

{t=a[j]；

a[j]=a[j+1]；

a[j+1]=t；}}

2.4 算法性能分析

有n个元素参加排序要进行n1趟比较，第i趟要进行ni次两两比较。时间复杂度为O(n2)。冒泡排序算法稳定，比较次数已知，但是该算法速度慢，每次只能比较和移动相邻两个数据元素，移动数据元素的次数多。

3 改进的冒泡排序法

3.1 算法思想

冒泡排序法存在的不足之处是在排序过程中，虽然数据序列已经按要求排序完成，但程序无法判断是否完成排序，程序仍然要进行下一趟的排序，这样势必浪费了程序执行的时间，降低了程序的执行效率。为了解决这一不足，在程序中可以设置一个标志变量flag，每一趟排序开始前设置flag值为1，表示待排序的数据序列是无序的。如果在程序的执行过程中发生数据交换操作，则修改flag值为0。当前趟排序结束后检查flag标志，若flag的值为1，表示在当前趟排序过程中没有进行过交换数据，则结束排序过程，否则继续进行下一趟排序。

3.2 实现改进冒泡排序法核心代码

for(i=0；i

{flag=1； //设置标志变量flag的值为1

for(j=0；j

if(a[j]>a[j+1]) //相邻元素比较，前者大于后者则交换

t=a[j]；

a[j]=a[j+1]；

a[j+1]=t；

flag=0； //发生数据交换，修改标志flag的值为0

}

if(flag==1) //本趟排序中未发生数据交换，则终止循环，即排序完成

break；

}

3.3 算法性能分析

若数据序列的初始状态为“正序”，则冒泡排序过程只需进行一趟排序，在排序过程中只需进行n1次比较，且不移动数据元素。若数据序列的初始状态为“逆序”，则需进行n(n1)/2次比较和数据元素交换，而完成两个数据元素交换需移动操作3次，故移动次数达到最大3n(n1)/2。改进的冒泡排序算法的时间复杂度为O(n2)，改进的冒泡排序算法是稳定的排序算法。

4 选择排序法

4.1 算法思想

假设数组有n个元素，第一趟从第一个元素开始，第一个元素和第二个元素开始到第n个元素按顺序作比较，按排序要求找到最小元素的位置，然后用该位置和第一个元素的下标进行比较，如果不相等则两元素进行交换，这样第一个元素将是n个元素中的最小值。接下来第二趟从第二个元素开始逐一和其后的n2个元素两两比较，在进行n2次比较后找到剩下n1个元素中的最小值的位置，然后用该位置和第一个元素的下标进行比较，如果不相等则两元素进行交换，第二个元素将是后n1个元素中的最小值。依次类推一直到第n1趟最后两个元素进行比较并得到两个元素中的较小值的位置。

4.2 模拟排序执行过程

假设一个整型数组有5个元素，分别为23、12、5、16、10，用变量k保存最小值的下标，排序执行过程如下所示：

第一趟： 23 12 5 16 10 (第一趟比较前元素)

第一次： k=1 (由于23>12)

第二次： k=2 (由于 12>5)

第三次： k=2 (由于 5

第四次： k=2 (由于 5

第一趟比较后，由于0！=2，则a[0]与a[2]交换。

第二趟： 5 12 23 16 10 (第二趟比较前元素)

第一次： k=1 (由于 12

第二次： k=1 (由于 12

第三次： k=4 (由于 12>10)

第二趟比较后，由于1！=4，则a[1]与a[4]交换。

第三趟： 5 10 23 16 12

第一次： k=3 (由于 23>16)

第二次： k=4 (由于 16>12)

第三趟比较后，由于2！=4，则a[2]与a[4]交换。

第四趟： 5 10 12 16 23

第一次： k=4 (由于 16>23)

第四趟比较后，由于3！=4，则a[3]与a[4]交换。

5 10 12 16 23

4.3 实现选择排序法核心代码

for(i=0；i

{k=i； //假设当前趟的第一个数为最小值，下标记在k中

for(j=i+1；j

if(a[k]>a[j]) //若其后有比最小值更小的，则将其下标记在k中

k=j；

if(k！=i) //若k和i值不相等，说明在其后找到比其更小的数

{ //交换最小值和当前趟序列的第一个数

t=a[i]；

a[i]=a[k]；

a[k]=t}

4.4 算法性能分析

有n个元素参加排序要进行n1趟比较，第i趟要进行ni次两两比较，每趟最多进行一次数据交换，其余元素的相对位置不变。时间复杂度为O(n2)。选择排序算法稳定，比较次数与冒泡排序一样，数据移动次数比冒泡排序少，算法速度还是慢。

5 直接插入排序法

5.1 算法思想

将序列分为有序序列和无序序列，依次从无序序列中取出元素值插入到有序序列的合适位置。初始是有序序列中只有第一个数，其余n1个数组成无序序列，则n个数需进行n1次插入。初始是有序序列中只有第一个数，其余n1个数组成无序序列，则n个数需进进n1次插入。寻找在有序序列中插入位置可以从有序序列的最后一个数往前找，在未找到插入点之前可以同时向后移动元素，为插入元素准备空间。

假设数组有n个元素，第一趟首先对前两个元素进行比较，按排序要求排列好，第二趟将第3个元素与前两个已排好序的元素做比较，按排序要求找到其相应的位置，将第3个元素插入到该位置上。以此类推，直到所有的元素排好序为止。

5.2 模拟排序执行过程

待排序列： 23 12 5 16 10

第一趟： 12 23 5 16 10 (23插入12之后，23后移)

第二趟： 5 12 23 16 10 (5插入12之前，12、23依次后移)

第三趟： 5 12 16 23 10 (16插入23之前，23后移)

第四趟： 5 10 12 16 23 (10插入12之前，12、16、23依次后移)

5.3 实现直接插入排序法核心代码

for(i=1；i

{ t=a[i]； //将待插入数暂存于变量t中

j=i1； //在有序序列(下标0 ～ i1)中寻找插入位置，从最后一个数往前找

while(j>=0&&t

a[j+1]=a[j]； //当前元素后移一个位置

j；

a[j+1]=t；//找到插入位置后将待插入数插入该位置，注意下标值j加1为插入位置

5.4 算法性能分析

有n个元素参加排序要进行n1趟比较。时间复杂度为O(n2)。直接插入排序算法稳定，执行速度快，但是该算法的数据比较次数不确定，比较次数越多，插入点后的数据移动次数越多，特别是当数据总量庞大的时候。

6 结语

通过对顺序比较法、选择排序法、冒泡排序法、改进的冒泡排序法和直接插入排序法的介绍，并从排序算法的思想、模拟排序执行过程、实现排序的算法代码及算法性能分析四个方面进行了详细的解析。本文可以帮助C语言初学者轻松理解几种常用的排序算法。

参考文献：

[1] 谭浩强.C语言程序设计[M].第3版.北京：清华大学出版社，2005.

[2] 范兴福.C程序设计[M].北京：机械工业出版社，2008.

[3] 严蔚敏，吴伟民.数据结构：C语言版[M].北京：清华大学出版社，1997.