------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------
1、C语言选择排序算法及代码
基本思想及举例说明选择排序(从小到大)的基本思想是,首先,选出最小的数,放在第一个位置;然后,选出第二小的数,放在第二个位置;以此类推,直到所有的数从小到大排序。
在实现上,我们通常是先确定第i小的数所在的位置,然后,将其与第i个数进行交换。
下面,以对 3 2 4 1 进行选择排序说明排序过程,使用min_index 记录当前最小的数所在的位置。
第1轮 排序过程 (寻找第1小的数所在的位置)
3 2 4 1(最初, min_index=1)
3 2 4 1(3 > 2, 所以min_index=2)
3 2 4 1(2 < 4, 所以 min_index=2)
3 2 4 1(2 > 1, 所以 min_index=4, 这时候确定了第1小的数在位置4)
1 2 4 3 (第1轮结果,将3和1交换,也就是位置1和位置4交换)
第2轮 排序过程 (寻找第2小的数所在的位置)
1 2 4 3(第1轮结果, min_index=2,只需要从位置2开始寻找)
1 2 4 3(4 > 2, 所以min_index=2)
1 2 4 3(3 > 2, 所以 min_index=2)
1 2 4 3(第2轮结果,因为min_index位置刚好在第2个位置,无需交换)
第3轮 排序过程 (寻找第3小的数所在的位置)
1 2 4 3(第2轮结果, min_index=3,只需要从位置2开始寻找)
1 2 4 3(4 > 3, 所以min_index=4)
1 2 3 4(第3轮结果,将3和4交换,也就是位置4和位置3交换)
至此,排序完毕。
总结及实现
选择排序对大小为N的无序数组R[N]进行排序,进行N-1轮选择过程。第i轮选取第i小的数,并将其放在第i个位置上。当第N-1次完成时,第N小(也就是最大)的数自然在最后的位置上。
下面给出选择排序的C语言实现。
#include<stdio.h>
#include<stdlib.h>
#define N 8
void select_sort(int a[],int n);
//选择排序实现
void select_sort(int a[],int n)//n为数组a的元素个数
{
//进行N-1轮选择
for(int i=0; i<n-1; i++)
{
int min_index = i;
//找出第i小的数所在的位置
for(int j=i+1; j<n; j++)
{
if(a[j] < a[min_index])
{
min_index = j;
}
}
//将第i小的数,放在第i个位置;如果刚好,就不用交换
if( i != min_index)
{
int temp = a[i];
a[i] = a[min_index];
a[min_index] = temp;
}
}
}
int main()
{
int num[N] = {89, 38, 11, 78, 96, 44, 19, 25};
select_sort(num, N);
for(int i=0; i<N; i++)
printf("%d ", num[i]);
printf("\n");
system("pause");
return 0;
}
注意:选择排序是一种不稳定的排序算法,可能会打乱两个相同数字的原有顺序。
例如,序列 5 8 5 2 9, 按照从小到大排序,第一轮会将第1个数字5会和2交换,那么原序列中2个5的相对前后顺序就被破坏了,所以选择排序是一种不稳定的排序算法。
2、C语言冒泡排序算法及代码
基本思想及举例说明
冒泡排序的基本思想就是不断比较相邻的两个数,让较大的元素不断地往后移。经过一轮比较,就选出最大的数;经过第2轮比较,就选出次大的数,以此类推。
下面以对 3 2 4 1 进行冒泡排序说明。
第一轮 排序过程
3 2 4 1 (最初)
2 3 4 2 (比较3和2,交换)
2 3 4 1 (比较3和4,不交换)
2 3 1 4 (比较4和1,交换)
第一轮结束,最大的数4已经在最后面,因此第二轮排序只需要对前面三个数进行再比较。
第二轮 排序过程
2 3 1 4 (第一轮排序结果)
2 3 1 4 (比较2和3,不交换)
2 1 3 4 (比较3和1,交换
第二轮结束,第二大的数已经排在倒数第二个位置,所以第三轮只需要比较前两个元素。
第三轮 排序过程
2 1 3 4 (第二轮排序结果)
1 2 3 4 (比较2和1,交换)
至此,排序结束。
算法总结及实现
对于具有N个元素的数组R[n],进行最多N-1轮比较;
第一轮,逐个比较(R[1], R[2]), (R[2], R[3]), (R[3], R[4]), ……. (R[N-1], R[N]) ; 最大的元素会被移动到R[N]上。
第二轮,逐个比较(R[1], R[2]), (R[2], R[3]), (R[3], R[4]), ……. (R[N-2], R[N-1]);第二大元素会被移动到R[N-1]上。
。。。。
以此类推,直到整个数组从小到大排序。
下面给出了冒泡排序的一般实现和优化实现。一般实现是教科书里常见的实现方法,无论数组是否排序好了,都会进行N-1轮比较; 而优化实现,在数组已经排序好的情况下,会提前退出比较,减小了算法的时间复杂度。
#include<stdio.h>
#include<stdlib.h>
#define N 8
void bubble_sort(int a[],int n);
//一般实现
void bubble_sort(int a[],int n)//n为数组a的元素个数
{
//一定进行N-1轮比较
for(int i=0; i<n-1; i++)
{
//每一轮比较前n-1-i个,即已排序好的最后i个不用比较
for(int j=0; j<n-1-i; j++)
{
if(a[j] > a[j+1])
{
int temp = a[j];
a[j] = a[j+1];
a[j+1]=temp;
}
}
}
}
//优化实现
void bubble_sort_better(int a[],int n)//n为数组a的元素个数
{
//最多进行N-1轮比较
for(int i=0; i<n-1; i++)
{
bool isSorted = true;
//每一轮比较前n-1-i个,即已排序好的最后i个不用比较
for(int j=0; j<n-1-i; j++)
{
if(a[j] > a[j+1])
{
isSorted = false;
int temp = a[j];
a[j] = a[j+1];
a[j+1]=temp;
}
}
if(isSorted) break; //如果没有发生交换,说明数组已经排序好了
}
}
int main()
{
int num[N] = {89, 38, 11, 78, 96, 44, 19, 25};
bubble_sort(num, N); //或者使用bubble_sort_better(num, N);
for(int i=0; i<N; i++)
printf("%d ", num[i]);
printf("\n");
system("pause");
return 0;
}
3、C语言插入排序算法及代码
基本思想及举例说明
插入排序的基本思想是,将元素逐个添加到已经排序好的数组中去,同时要求,插入的元素必须在正确的位置,这样原来排序好的数组是仍然有序的。
在实际使用中,通常是排序整个无序数组,所以把这个无序数组分为两部分排序好的子数组和待插入的元素。第一轮时,将第一个元素作为排序好的子数组,插入第二个元素;第二轮,将前两个元素作为排序好的数组,插入第三个元素。以此类推,第i轮排序时,在前i个元素的子数组中插入第i+1个元素。直到所有元素都加入排序好数组。
下面,以对 3 2 4 1 进行选择排序说明插入过程,使用j记录元素需要插入的位置。排序目标是使数组从小到大排列。
第1轮
[ 3 ] [ 2 4 1 ] (最初状态,将第1个元素分为排序好的子数组,其余为待插入元素)
[ 3 ] [ 2 4 1 ] (由于3>2,所以待插入位置j=1)
[ 2 3 ] [ 4 1 ] (将2插入到位置j)
第2轮
[ 2 3 ] [ 4 1 ] (第1轮排序结果)
[ 2 3 ] [ 4 1 ] (由于2<4,所以先假定j=2)
[ 2 3 ] [ 4 1 ] (由于3<4,所以j=3)
[ 2 3 4 ] [ 1 ] (由于4刚好在位置3,无需插入)
第3轮
[ 2 3 4 ] [ 1 ] (第2轮排序结果)
[ 2 3 4 ] [ 1 ] (由于1<2,所以j=1)
[1 2 3 4 ] (将1插入位置j,待排序元素为空,排序结束)
算法总结及实现
选择排序对大小为N的无序数组R[N]进行排序,进行N-1轮选择过程。首先将第1个元素作为已经排序好的子数组,然后将剩余的N-1个元素,逐个插入到已经排序好子数组;。因此,在第 i轮排序时,前i个元素总是有序的,将第i+1个元素插入到正确的位置。
#include<stdio.h>
#include<stdlib.h>
#define N 8
void insert_sort(int a[],int n);
//插入排序实现,这里按从小到大排序
void insert_sort(int a[],int n)//n为数组a的元素个数
{
//进行N-1轮插入过程
for(int i=1; i<n; i++)
{
//首先找到元素a[i]需要插入的位置
int j=0;
while( (a[j]<a[i]) && (j<i))
{
j++;
}
//将元素插入到正确的位置
if(i != j) //如果i==j,说明a[i]刚好在正确的位置
{
int temp = a[i];
for(int k = i; k > j; k--)
{
a[k] = a[k-1];
}
a[j] = temp;
}
}
}
int main()
{
int num[N] = {89, 38, 11, 78, 96, 44, 19, 25};
insert_sort(num, N);
for(int i=0; i<N; i++)
printf("%d ", num[i]);
printf("\n");
system("pause");
return 0;
}
注意:插入排序是一种稳定的排序算法,不会改变原有序列中相同数字的顺序。
插入排序是在一个已经有序的小序列的基础上,一次插入一个元素。当然,刚开始这个有序的小序列只有1个元素,就是第一个元素。比较是从有序序列的末尾开始,也就是想要插入的元素和已经有序的最大者开始比起,如果比它大则直接插入在其后面,否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的,那么插入元素把想插入的元素放在相等元素的后面。所以,相等元素的前后顺序没有改变,从原无序序列出去的顺序就是排好序后的顺序,所以插入排序是稳定的。
4、C语言二分查找(折半查找)算法及代码
二分查找也称折半查找,其优点是查找速度快,缺点是要求所要查找的数据必须是有序序列。该算法的基本思想是将所要查找的序列的中间位置的数据与所要查找的元素进行比较,如果相等,则表示查找成功,否则将以该位置为基准将所要查找的序列分为左右两部分。接下来根据所要查找序列的升降序规律及中间元素与所查找元素的大小关系,来选择所要查找元素可能存在的那部分序列,对其采用同样的方法进行查找,直至能够确定所要查找的元素是否存在,具体的使用方法可通过下面的代码具体了解。
#include <stdio.h>
binarySearch(int a[], int n, int key)
{
int low = 0;
int high = n - 1;
while(low<= high){
int mid = (low + high)/2;
int midVal = a[mid];
if(midVal<key)
low = mid + 1;
else if(midVal>key)
high = mid - 1;
else
return mid;
}
return -1;
}
int main()
{
int i, val, ret;
int a[8]={-32, 12, 16, 24, 36, 45, 59, 98};
for(i=0; i<8; i++)
printf("%d\t", a[i]);
printf("\n请输人所要查找的元素:");
scanf("%d",&val);
ret = binarySearch(a,8,val);
if(-1 == ret)
printf("查找失败 \n");
else
printf ("查找成功 \n");
return 0;
}
运行结果:
-32 12 16 24 36 45 59 98
请输入所要查找的元素:12
查找成功
在查找过程中,先将序列中间位置的元素与所要查找的元素进行比较,发现要查找的元素位干该位置的左部分序列中。接下来将mid的左边一个元素作为 high,继续进行二分查找,这时mid所对应的中间元素刚好是所要查找的元素,查找结束,返回查找元素所对应的下标。在main函数中通过返回值来判断查找是否成功,如果查找成功.就打印输出“查找成功”的信息,否则输出“查找失畋”的信息。
------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------