选择排序的优化c语言,C语言 五种排序方式

这几天看了郝斌的数据结构视频，对于各种排序方式有了更深刻的理解。下面与大家分享下我的学习成果，不足之处忘指正。

PS：博文中的代码都是自己敲的，便于理解。

这里讲的五种排序方式，是指冒泡排序、直接选择排序、直接插入排序、快速排序以及二路归并排序。

冒泡排序：排序的思路正如“冒泡”二字，每次比较第i和i+1个位置的值，若a[i]>a[i+1],则交换。这样第一趟下来，最大的数在第n-1个位置；第二趟下来，次最大的数在第n-2个位置，依此类推，直到所有的数排序完毕。

C语言的代码为(p指向数组首元素，len表示数组元素的个数)：void bubbleSort(int *p, int len)

{

int i = 0;

int j = 0;

int temp = 0;

for (i = 0; i < len-1; i++)

{

for (j = 0; j < len-1-i; j++)

{

if (p[j] > p[j+1])

{

temp = p[j];

p[j] = p[j+1];

p[j+1] = temp;

}

}

}

}

冒泡排序是稳定的，平均时间复杂度为o(n2)

直接选择排序。若是从小到大排序，则第1趟把最小的值放在第0个位置，第2趟把次最小值放在第1个位置，依此类推，直到所有的数排序完毕。

c语言代码为：void selectSort(int *p, int len)

{

int i = 0;

int j = 0;

int temp = 0;

for (i = 0; i < len; i++)

{

for (j = i+1; j < len; j++)

{

if (p[j] < p[i])

{

temp = p[i];

p[i] = p[j];

p[j] = temp;

}

}

}

}

直接选择排序是不稳定的算法，平均时间复杂度也是o(n2)。看到网上很有人认为选择排序是稳定的算法，其实不然，例如5,3,5,2,1。第一趟排序完后，第一个5与最后的1交换，位置为2的5自然在原本位置为0的5的前面了。

直接插入排序。假定前i个数已经有序，直接插入排序是把第i+1个数插入到前i个数中的合适位置，重新组成大小为i+1个数的有序序列。

C语言实现代码：void insertSort(int *p,int len)

{

int i = 0;

int j = 0;

int temp = 0;

for (i = 1; i < len; i++)

{

temp=p[i];

for (j = i; j > 0 && temp < p[j-1]; j--)

{

p[j] = p[j-1];

}

p[j] = temp;

}

return;

}

直接插入排序是稳定的，平均时间复杂度也是o(n2)。

快速排序。快速排序采用递归思想，速度自然快很多。假定有n个数，参考值value，也就是我们的比较对象为数组的第一个元素，那么一趟快速排序后，value左侧的值都比value小，右侧的值都比value大。然后再按此方法对这两部分数据分别进行快速排序，依此类推，直到整个数据变成有序序列。

C语言代码如下：void quickSort(int *p,int low ,int high)

{

int posi = 0;

if (high > low)

{

posi = findPosi(p,low,high);

if (posi > low){

quickSort(p,low,posi-1);

}

if (posi < high){

quickSort(p,posi+1,high);

}

}

}

int findPosi(int *p,int low,int high)

{

int value = *(p+low);

while (high > low)

{

while(p[high] >= value && high > low)

{

high--;

}

p[low] = p[high];

while (p[low] <= value && low < high)

{

low ++;

}

p[high] = p[low];

}

p[low] = value;

return low;

}

快速排序是不稳定的，平均时间复杂度是o(log2n)。

最后是归并排序。二路归并排序的思想是分而治之，即divide and conquer。divide:不断地拆分数组，直到每个数组都只有一个元素。conquer:并，把拆分后的数组按关键字排序，不断合并，直到整个数据有序。很明显，二路归并排序利用了递归的思想。

下面给出它的C语言实现：void divide(int *p,int low,int high){

int mid = (low + high)/2;

if (low < high){

divide(p,low,mid);

divide(p,mid+1,high);

}

GuiBingSort(p,low,mid,high);

}

void GuiBingSort(int *p,int low,int mid, int high){

int leftIndex = low;

int rightIndex = mid+1;

int tempIndex = 0;

int tempLen = high-low+1;

int *temp = (int *)malloc(sizeof(int)*(tempLen));

if (NULL == temp){

printf("分配内存失败！\n");

return;

}

while(leftIndex <= mid && rightIndex <= high){

if (p[leftIndex] <= p[rightIndex]){

temp[tempIndex] = p[leftIndex];

leftIndex++;

}else{

temp[tempIndex] = p[rightIndex];

rightIndex++;

}

tempIndex++;

}

if (leftIndex > mid){

while(rightIndex <= high){

temp[tempIndex] = p[rightIndex];

rightIndex++;

tempIndex++;

}

}else if (rightIndex > high){

while (leftIndex <= mid){

temp[tempIndex] = p[leftIndex];

leftIndex++;

tempIndex++;

}

}

int i = 0;

for (i = 0; i < tempLen; i++ ){

p[i+low] = temp[i];

}

free(temp);

return;

}

归并排序是稳定的，平均时间复杂度是o(log2n)。

最后附上main函数的代码：int main()

{

int a[7] = {1,5,4,89,23,100,-3};

int len = sizeof(a)/sizeof(int);

// printf("插入排序之后\n");

//insertSort(a,len);

showArray(a,len);

// printf("选择排序之后\n");

// selectSort(a,len);

showArray(a,len);

// printf("冒泡排序之后:\n");

//bubbleSort(a,len);

showArray(a,len);

// printf("快速排序之后\n");

// quickSort(a,0,len-1);

showArray(a,len);

printf("归并排序之后\n");

divide(a,0,len-1);

showArray(a,len);

return 0;

}