c语言数组选择排序

Ⅰ c语言如何用选择法排序任意输入十个数（从大到小、从小到大）

#include
<stdio.h>
main(void)
{
int
i,j,a[10],p=0,t=0,temp;
printf("请输入原数组：\n");
for(j=0;j<10;j++)
scanf("%d",&a[j]);
temp=a[0];
for(j=0;j<9;j++)
{
t=j;
temp=a[j];
for(i=j+1;i<10;i++)
if(temp>a[i])
//这是由小到大排序
如果是大到小则改为
if(temp<a[i])
{temp=a[i];p=i;}
{temp=a[p];a[p]=a[t];a[t]=temp;}
}
printf("排序后的数组为：\n");
for(j=0;j<10;j++)
printf("%d
",a[j]);
}

Ⅱ c语言 选择法排序

void sa(int array[],int n)
{
int i,j,k,temp;
for(i=0;i<10;i++)
{
k=i; //保存i的值，用k来进行循环排序
for(j=i+1;j<n;j++) //将第i个元素后面的元素与第i个元素进行比较
if(array[j]<array[k]) //如果第k=i个元素后面的元素小于i号元素，交换两个元素的标号， 这样就将最小元素的标号放到最前面
k=j; //交换标号
temp=array[k]; //循环结束后，交换两个标号下的元素的值
array[k]=array[i];
array[i]=temp;
}
}
这个程序实现的是由小到大的排序。第二个循环里面，就是i号元素后面最小的元素对应的标号放到k中，在交换当前元素与k号元素中的值，实现由大到小排序

Ⅲ C语言(数组排序)

1.选择排序思想：假定按从大到小排序，比较数组中所有数的大小，挑出最大的元素将其与第一个元素交换位置，然后比较除第一个元素外其他各元素的大小，挑出最大的元素与第二个元素交换位置，依此类推，完成排序。

2.给你解释开头的n-2：k=0 to k=n-2,k总共取n-1个元素，当k=n-2时，对应a[n-2]为数组倒数第二个元素，此时i=n-i,a[i]即a[n-1]对应数组最后一个元素，当比较完a[n-2]和a[n-1]并排序后，整个数组就完成了排列。

3.代码：
for(k=0;k<=n-2;k++)
{
index=k;
for(i=k+1;i<=n-1;i++)
{
if(a[i]<a[index])
{
index=i;
}
}
temp=a[k],a[k]=a[index],a[index]=temp;
}

Ⅳ C语言中的选择排序法是什么

选择排序（Selection sort）是一种简单直观的排序算法。工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

以下是一个实现选择排序的例子：

#defineSWAP(x,y,t)((t)=(x),(x)=(y),(y)=(t))
//将list中的n个数据，通过选择排序算法排序。
voidselete_sort(intlist[],intn)
{
inti,j,min,temp;
for(i=0;i<n-1;i++){
min=i;
for(j=i+1;j<n;j++)//找出最小元素的下标。
if(list[j]<list[min])
min=j;
SWAP(list[i],list[min],temp);//交换最小元素到当前起始位置。
}
}

Ⅳ C语言数组A用选择排序

定义一个整型数组a[n],下面用五种方法对其从小到大排序。
（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; /*缩小间距值*/
}
}
上面我们已经对几种排序法作了介绍，现在让我们写个主函数检验一下。
#include<stdio.h>
/*别偷懒，下面的"..."代表函数体，自己加上去哦！*/
void bubble(int *a,int n)
{
...
}
void choise(int *a,int n)
{
...
}
void quick(int *a,int i,int j)
{
...
}
void insert(int *a,int n)
{
...
}
void shell(int *a,int n)
{
...
}
/*为了打印方便，我们写一个print吧。*/
void print(int *a,int n)
{
int i;
for(i=0;i<n;i++)
printf("%5d",a[i ]);
printf("\n");
}
main()
{ /*为了公平，我们给每个函数定义一个相同数组*/
int a1[]={13,0,5,8,1,7,21,50,9,2};
int a2[]={13,0,5,8,1,7,21,50,9,2};
int a3[]={13,0,5,8,1,7,21,50,9,2};
int a4[]={13,0,5,8,1,7,21,50,9,2};
int a5[]={13,0,5,8,1,7,21,50,9,2};
printf("the original list:");
print(a1,10);
printf("according to bubble:");
bubble(a1,10);
print(a1,10);
printf("according to choise:");
choise(a2,10);
print(a2,10);
printf("according to quick:");
quick(a3,0,9);
print(a3,10);
printf("according to insert:");
insert(a4,10);
print(a4,10);
printf("according to shell:");
shell(a5,10);
print(a5,10);
}

Ⅵ c语言数组排序

你输入的时候就不可能通过，怎么可能存在a[3]啊，只能输入3个数字，否则越界了。简单的排序有冒泡，选择，基数，归并，希尔，插入，还有堆排序。

Ⅶ C语言怎样对二维数组中每个元素进行选择排序

#include<stdio.h>
#include"stdlib.h"
#include"time.h"
intmain(intargc,char*argv[]){
inta[5][8],i,j,k,t,*p;
printf("排序前:
");
srand((unsigned)time(NULL));
for(i=0;i<5;i++){//为二维数组赋值
for(j=0;j<8;printf("%3d",a[i][j++]=rand()%100));
printf("
");
}
printf("排序后:
");
p=(int*)a;//降为一维,这样排序简单
for(t=i=0;i<40;i++){//选择法排序
for(k=i,j=k+1;j<40;j++)
if(p[k]>p[j])
k=j;
if(k!=i)
j=p[k],p[k]=p[i],p[i]=j;
printf(++t%8?"%3d":"%3d
",p[i]);
}
return0;
}

Ⅷ C语言数组选择排序法，超简单，求解

for语句有4个部分内容for ( A;B;C ) D;其中A是初始化语句，每个for只执行A一次，B是循环条件，每次循环前执行判断，如果不满足则结束循环，D是在满足循环条件时执行的，可以是一句或多句(多句时用大括号括起来做整体处理)，C是在执行D之后进行的后续处理。for语句执行的顺序是：A,B,D,C,B,D,C,B,D,C,...,B结束

for(i=0;i<9;i++){
iTemp=a[i];iPos=i;
for(j=i+1;j<10;j++){
if(a[j]<iTemp){iTemp=a[j];iPos=i;}
}
a[iPos]=a[i];a[i]=iTemp;
}

假设数组a中输入了十个数为：1,2,5,4,6,8,7,9,10,3，通过手动单步执行程序(把自己当成计算机)，分析理解for语句的含义。

i=0;[i=0],i<9成立,开始循环
iTemp=a[i];[iTemp=a[0]=1],iPos=i;[iPos=0]
j=i+1;[j=0+1=1],j<10成立,开始循环:a[j]<iTemp不成立[a[j]=a[1]=2,2<1不成立],跳过不执行
j++;[j=2],j<10成立,继续循环：a[j]<iTemp不成立[5<1],跳过不执行
j++;[j=3],j<10成立,继续循环：a[j]<iTemp不成立[4<1],跳过不执行
j++;[j=4],j<10成立,继续循环：a[j]<iTemp不成立[6<1],跳过不执行
...//没有条件满足让if语句条件能得到执行，因为a[1]～a[9]都不小于iTemp
j++;[j=10],j<10不成立,结束循环
a[0]=a[0];a[0]=1;实际上a[0]值未变，通过以上处理a[0]保存a[0]之后所有数组中最小值
i++;[i=1],i<9成立,继续循环
iTemp=a[i];[iTemp=a[1]=2],iPos=i;[iPos=1]
j=i+1;[j=2],j<10成立,开始循环：a[j]<iTemp不成立[5<2],跳过不执行
j++;[j=3],j<10成立,继续循环：a[j]<iTemp不成立[4<2],跳过不执行
...//没有条件满足让if语句条件能得到执行，因为a[2]～a[9]都不小于iTemp
j++;[j=10],j<10不成立,结束循环
a[1]=a[1];a[1]=2;实际上a[1]值未变，通过以上处理a[1]保存a[1]之后所有数组中最小值
i++;[i=2],i<9成立,继续循环
iTemp=a[i];[iTemp=a[2]=5],iPos=i;[iPos=2]
j=i+1;[j=3],j<10成立,开始循环:a[j]<iTemp成立,iTemp=a[j];[iTemp=4],iPos=j;[iPos=3]
j++;[j=4],j<10成立,继续循环：a[j]<iTemp不成立[6<4],跳过不执行
...
j++;[j=9],j<10成立,继续循环：a[j]<iTemp成立,,iTemp=a[j];[iTemp=3],iPos=j;[iPos=9]
j++;[j=10],j<10不成立,结束循环
a[9]=a[2];a[2]=3;通过以上处理a[2]与a[2]之后所有数组中最小值的a[9]值互换
现在数组变成:1,2,3,4,6,8,7,9,10,5
...//每次i循环都会导致当前a[i]与之后最小值的元素互换值，结果是a[i]保存之后最小值
i++;[i=9],i<9不成立，结束循环
至此数组按照从小到大顺序排序

上述循环中，i值指定当前要处理的元素，j值负责每次提供之后所有元素下标，在进行比较后，当前i指向元素会与之后最小值进行交换，保证当前元素是之后元素中最小的，从而进行9次这样的处理后数组按顺序已经排好序了。

Ⅸ C语言：用选择排序法对一个数组里的数进行排序，从小到大，要求选出小的进行排序

#include<stdio.h>

intmain()

{

inti=0;

inta[10]={0,5,2,3,6,9,8,7,4,1};

intj=0;

inttmp=0;

intm=sizeof(a)/sizeof(a[0]);//s数组大小

for(i=0;i<m-1;i++)//比较m-1次

{

for(j=0;j<m-i-1;j++)//最后一次比较a[m-i-1]与a[m-i-2]

{

if(a[j]>a[j+1])//如果a[j]比a[j+1]大则交换内容

{

tmp=a[j+1];

a[j+1]=a[j];

a[j]=tmp;

}

}

}

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

{

printf("%d",a[i]);//打印

}

printf(" ");

return0;

}

(9)c语言数组选择排序扩展阅读

C语言排序法

把一个数组进行排序可以使用选择排序法。选择排序法的原理在是每一趟循环寻找数组中最小的数的下标，然后按照递增的顺序放入数组中。

循环找出最小数的下标，该下标用min保存，直到比较完整个数组，即可找到最小的数，然后将该数放入数组的第一位，这样就排好了一个元素。

需要再嵌套一层外层循环即可排好所有元素。第二次循环就不用再比较第一个元素了，因为第一个元素已经排好，依次类推，每一次循环就会排好一个，进行n-1次循环即可排好所有元素。

Ⅹ 求C语言将数组元素大小排序！！

C语言将数组元素大小排序方法：

以下使用的是冒泡排序法实线数组从小到大排序。

思想：每次相邻两个数比较，若升序，则将大的数放到后面，一次循环过后，就会将最大的数放在最后。

10、2、3、4、5、6、9、8、7、1是输入的待排序的数列，经过第一次排序，将最大的,10放在最后，第二次排序，将剩下的2、3、4、5、6、9、8、7、1进行冒泡，将当前最大的9放在倒数第二的位置，以此类推。

以下是具体代码：

#include <stdio.h>

int main(){

int nums[10] = {10, 2, 3, 4, 5, 6, 9, 8, 7, 1};

int i, j, temp, isSorted;

//优化算法：最多进行 n-1 轮比较

for(i=0; i<10-1; i++){

isSorted = 1; //假设剩下的元素已经排序好了

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

if(nums[j] > nums[j+1]){

temp = nums[j];

nums[j] = nums[j+1];

nums[j+1] = temp;

isSorted = 0; //一旦需要交换数组元素，就说明剩下的元素没有排序好

}

}

if(isSorted) break; //如果没有发生交换，说明剩下的元素已经排序好了

}

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

printf("%d ", nums[i]);

}

printf(" ");

return 0;

}

(10)c语言数组选择排序扩展阅读：

其他将数组从小到大排序的算法

以下使用的是选择排序法实现数组从小到大排序。

思想：从第一个数开始，每次和后面剩余的数进行比较，若升序，则如果后边的数比当前数字小，进行交换，和后面的所有的数比较、交换后，就会将当前的最小值放在当前的位置

输入的序列为10、2、3、4、5、6、9、8、7、1进行一次排序后将最小的数放在了第一位(a[0]与它后面的所有数进行比较，若a[0]比后面的数大，进行交换)，以此类推。

以下是具体代码：

#include <stdio.h>

int main(void){

int a[1001];

int n,i,j,t;

scanf("%d",&n);//n为要排序的数的个数

//输入需要排序的数

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

scanf("%d",a+i);

//接下来进行排序

for(i=0;i<n-1;++i)//因为每次需要和a[i]后面的数进行比较,所以到a[n-2](倒数第2个元素)就行

{

for(j=i+1;j<n;++j)//j从i后一个开始,a[i]与a[j]进行比较

{

if(a[i]>a[j])//a[i]为当前值,若是比后面的a[j]大,进行交换

{

t=a[i];

a[i]=a[j];

a[j]=t;

}

}//每排序一次,就会将a[i](包括a[i])之后的最小值放在a[i]的位置

for(j=0;j<n;++j)

printf("%-5d",a[j]);

printf(" ");

}

return 0;

}