用c语言编写一个程序，实现一个简单的冒泡排序算法

#include<stdioh>

void main(){

int i,j,score[10],count=0,temp,sum=0;

double avg;

for(i=0;i<10;i++){ //输入10个学生的成绩，并求着10个学生的成绩总和

printf("请输入第%d个学生的成绩：",(i+1));

scanf("%d",&score[i]);

sum+=score[i];

}

avg=sum10/10; //求着这10个学生成绩的平均值

for(i=0;i<10;i++){ //统计小于平均分的学生人数

if(score[i]<avg){

count++;

}

}

for(i=0;i<10;i++){ //使用冒泡排序对这10个学生的成绩逆序排序

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

if(score[j]<score[j+1]){

temp=score[j];

score[j]=score[j+1];

score[j+1]=temp;

}

}

}

printf("最高成绩：%d分，平均成绩：%2f分,低于平均成绩的人数是：%d人!\n",score[0],avg,count);

}

外星人计算Pi的程序

一、源程序

本文分析下面这个很流行的计算PI的小程序。下面这个程序初看起来似乎摸不到头脑，

不过不用担心，当你读完本文的时候就能够基本读懂它了。

程序一：很牛的计算Pi的程序

int a=10000,b,c=2800,d,e,f[2801],g;

main() {

for(;b-c;)

f[b++]=a/5;

for(;d=0,g=c2;c -=14,printf("%4d",e+d/a),e=d%a)

for(b=c; d+=f[b]a,f[b]=d%--g,d/=g--,--b; d=b);

}

二、数学公式

数学家们研究了数不清的方法来计算PI,这个程序所用的公式如下：

1 2 3 k

pi = 2 + --- (2 + --- (2 + --- (2 + (2 + ---- (2 + )))))

3 5 7 2k+1

至于这个公式为什么能够计算出PI，已经超出了本文的能力范围。

下面要做的事情就是要分析清楚程序是如何实现这个公式的。

我们先来验证一下这个公式：

程序二：Pi公式验证程序

#include "stdioh"

void main()

{

float pi=2;

int i;

for(i=100;i>=1;i--)

pi=pi(float)i/(2i+1)+2;

printf("%f\n",pi);

getchar();

}

上面这个程序的结果是3141593。

三、程序展开

在正式分析程序之前，我们需要对程序一进行一下展开。我们可以看出程序一都是使用

for循环来完成计算的，这样做虽然可以使得程序短小，但是却很难读懂。根据for循环

的运行顺序，我们可以把它展开为如下while循环的程序：

程序三：for转换为while之后的程序

int a=10000,b,c=2800,d,e,f[2801],g;

main() {

int i;

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

f[i]=a/5;

while(c!=0)

{

d=0;

g=c2;

b=c;

while(1)

{

d=d+f[b]a;

g--;

f[b]=d%g;

d=d/g;

g--;

b--;

if(b==0) break;

d=db;

}

c=c-14;

printf("%4d",e+d/a);

e=d%a;

}

}

注：

for([1];[2];[3]) {[4];}

的运行顺序是[1],[2],[4],[3]。如果有逗号 *** 作符，例如：d=0,g=c2，则先运行d=0,

然后运行g=c2,并且最终的结果是最后一个表达式的值，也就是这里的c2。

下面我们就针对展开后的程序来分析。

四、程序分析

要想计算出无限精度的PI，我们需要上述的迭代公式运行无数次，并且其中每个分数也

是完全精确的，这在计算机中自然是无法实现的。那么基本实现思想就是迭代足够多次

，并且每个分数也足够精确，这样就能够计算出PI的前n位来。上面这个程序计算800位

，迭代公式一共迭代2800次。

int a=10000,b,c=2800,d,e,f[2801],g;

这句话中的2800就是迭代次数。

由于float或者double的精度远远不够，因此程序中使用整数类型（实际是长整型），分

段运算（每次计算4位）。我们可以看到输出语句 printf("%4d",e+d/a); 其中%4就是

把计算出来的4位输出，我们看到c每次减少14（ c=c-14;），而c的初始大小为2800，因

此一共就分了200段运算，并且每次输出4位，所以一共输出了800位。

由于使用整型数运算，因此有必要乘上一个系数，在这个程序中系数为1000，也就是说

，公式如下：

1 2 3 k

1000pi = 2k+ --- (2k+ --- (2k+ --- (2k+ (2k+ ---- (2k+ ))

)))

3 5 7 2k+1

这里的2k表示2000，也就是f[2801]数组初始化以后的数据,a=10000,a/5=2000,所以下面

的程序把f中的每个元素都赋值为2000：

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

f[i]=a/5;

你可能会觉得奇怪，为什么这里要把一个常数储存到数组中去，请继续往下看。

我们先来跟踪一下程序的运行：

while(c!=0) 假设这是第一次运行，c=2800，为迭代次数

{

d=0;

g=c2; 这里的g是用来做k/(2k+1)中的分子

b=c; 这里的b是用来做k/(2k+1)中的分子

while(1)

{

d=d+f[b]a; f中的所有的值都为2000，这里在计算时又把系数扩大了

a=10000倍。

这样做的目的稍候介绍，你可以看到

输出的时候是d/a,所以这不影

计算

g--;

f[b]=d%g; 先不管这一行

d=d/g; 第一次运行的g为22799+1，你可以看到g做了分母

g--;

b--;

if(b==0) break;

d=db; 这里的b为2799，可以看到d做了分子。

}

c=c-14;

printf("%4d",e+d/a);

e=d%a;

}

只需要粗略的看看上面的程序，我们就大概知道它的确是使用的那个迭代公式来计算Pi

的了，不过不知道到现在为止你是否明白了f数组的用处。如果没有明白，请继续阅读。

d=d/g,这一行的目的是除以2k+1，我们知道之所以程序无法精确计算的原因就是这个除

法。即使用浮点数，答案也是不够精确的，因此直接用来计算800位的Pi是不可能的。那

么不精确的成分在哪里？很明显：就是那个余数d%g。程序用f数组把这个误差储存起来

，再下次计算的时候使用。现在你也应该知道为什么d=d+f[b]a;中间需要乘上a了吧。

把分子扩大之后，才好把误差精确的算出来。

d如果不乘10000这个系数，则其值为2000，那么运行d=d/g；则是2000/(22799+1)，这

种整数的除法答案为0，根本无法迭代下去了。

现在我们知道程序就是把余数储存起来，作为下次迭代的时候的参数，那么为什么这么

做就可以使得下次迭代出来的结果为

接下来的4位数呢？

这实际上和我们在纸上作除法很类似：

0142

/——------

7 / 1

10

7

---------------

30

28

---------------

20

14

---------------

60

我们可以发现，在做除法的时候，我们通常把余数扩大之后再来计算，f中既然储存的是

余数，而f[b]a;则正好把这个余数扩大了a倍，然后如此循环下去，可以计算到任意精

度。

这里要说明的是，事实上每次计算出来的d并不一定只有4位数，例如第一次计算的时候

，d的值为31415926，输出4位时候，把低四位的值储存在e中间，e=d%a，也就是5926。

最后，这个c=c-14不太好理解。事实上没有这条语句，程序计算出来的仍然正确。只是

因为如果迭代2800次，无论分数如何精确，最后Pi的精度只能够达到800。

你可以把程序改为如下形式尝试一下：

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

{

d=0;

g=c2;

b=c;

while(1)

{

d=d+f[b]a;

g--;

f[b]=d%g;

d=d/g;

g--;

b--;

if(b==0) break;

d=db;

}

// c=c-14; 不要这句话。

printf("%4d",e+d/a);

e=d%a;

}

最后的答案仍然正确。

不过我们可以看到内循环的次数是c次，也就是说每次迭代计算c次。而每次计算后续位

数的时候，迭代次数减少14，而不影响精度。为什么会这样，我没有研究。另外最后的

e+d/a,和e=d/a的作用就由读者自己考虑吧。

--

#include<stdioh>

int main()

{int i,j,t,n,a[100];

printf("请输入有几个整数(<=100)：du");

scanf("%d",&n);

printf("请输入这%d个整数：zhi\n");

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

scanf("%d",&a[i]);

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

{k=i;

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

if(a[j]<a[k])

k=j;

t=a[i];a[i]=a[k];a[k]=t;

}

printf("排序以后的数：\n");

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

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

printf("\n");

return 0;

}

扩展资料：

在简单选择排序过程中，所需移动记录的次数比较少。最好情况下，即待排序记录初始状态就已经是正序排列了，则不需要移动记录。

最坏情况下，即待排序记录初始状态是按第一条记录最小，之后的记录从小到大顺序排列，则需要移动记录的次数最多为3（n-1）。

简单选择排序过程中需要进行的比较次数与初始状态下待排序的记录序列的排列情况无关。当i=1时，需进行n-1次比较；当i=2时，需进行n-2次比较；依次类推，共需要进行的比较次数是(n-1)+(n-2)+…+2+1=n(n-1)/2，即进行比较 *** 作的时间复杂度为O(n^2)，进行移动 *** 作的时间复杂度为O(n)。

参考资料来源：百度百科-简单选择排序

使用数据结构 堆 。这个思维复杂度较小。

把n个元素(没对苹果的数量)放到一个[堆]里，每次从[堆]里取出2个最小的合并成一个(每次合并后所消耗的体力值加上这堆的重量)，然后把合并出来的新的一堆苹果的数量作为一个元素放进[堆]里。接着继续取两个最小的。。直到[堆]里只剩下一个元素。输出所消耗的体力值即可。

还有一个方法是用2个队列，但是思维复杂度高点，这里就不介绍了。

这是我无聊写的一个小程序，可是却有两三页，其实，C语言已经很简短了！我给你一段汇编语言看看。

3从键盘读入一个四位的十六进制数，CRT显示等值的二进制数

由于每个十六进制数位对应4个二进制，所以每读入一个十六进制位后，即可将其对应的4个二进制位依次输出。由于数字‘0’~ ‘9’的ASCⅡ码为30H～39H,字母‘a’～‘f’与 ‘A’～‘F’的ASCⅡ码为61H～66H 与41H～46H ，因此，如果输入的字母为数字‘0’～‘9’，则其低4位即为对应的二进制位；如果输入的字符为字母‘a’～‘f’或‘A’～‘F’，则需要减7，然后通过移位将低4位依次输出。

汇编程序如下：

DATA SEGMENT

MSG1DB　 'Hex:',　'$'

MSG2DB0DH,　0AH,　'Binary:',　'$'

COUNT EQU 4

BUF DB 4 DUP()

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START: MOV  AX, DATA

MOV  DS, AX

LEA  DX,  MSG1

MOV  AH,  9

INT  21H

 MOV  CX,  COUNT

 MOV  SI,   0

INPUT:               ；通过四次循环从键盘读入四位十六进制数

MOV  AH, 1

INT  21H

MOV  BUF[SI],  AL

DEC  CX

INC   SI

CMP  CX,  0

JNZ  INPUT

NEXT3: LEA  DX,  MSG2

MOV  AH,  9

INT  21H

MOV  CX,  COUNT

MOV  SI,  0

NEXT2: MOV  BL,  BUF[SI]

CMP   BL ,  '9'

JBE   OK  ； 读入的字符＜＝9　转向　OK:

SUB   BL,   7　 ;读入字符>= 9   减7

OK:   PUSH   CX

MOV  CL  ,4

SHL  BL,  CL   ; 逻辑左移4位,低4位à高4位

MOV  CX,  4    ; 4次循环将当前处理字符的4位二进制输出

NEXT1: MOV   DL,  '0'

SHL   BL,  1

JNC   SKIP

      INC   DL

SKIP:  MOV   AH,  2

INT  21H

LOOP   NEXT1

POP  CX     ;

INC   SI

LOOP   NEXT2  ; 4次循环将4位十六进制数,每位转换为对应的4位二进制

EXIT:  MOV  AH,   4CH

INT   21H

CODE   ENDS

    END START

来自

fsd999999的博客

他的博客上还有几段，你看了以后就知道C语言有多简短了。

>

注释写在了后面,主要思想是设置了两个数组。left[3]表示没过河的集合，right[3]表示已经过河的集合。0，1，2分别表示菜，羊，狼，-2表示空（比如白菜过河了那么left[0]就等于-2)。输出结果中用x to left 和x to right表示元素的运动方向。

程序如下：

#include <stdioh>

#include <mathh>

int kong(int left[])

//判断是否全都过河了，0表示没全过河，1表示全过河了

{

int i;

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

{

if(left[i]!=-2)

return 0;

}

return 1;

}

void ltor(int left[],int right[])

//到对岸时选一个元素

{

int i;

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

if(left[i]!=-2)

{

if(abs(left[(i+1)%3]-left[(i+2)%3])!=1)

//此句中如果两数相减有绝对值为一的元素情况说明有吃与被吃的关系存在，即不能运该元素

{

right[i]=left[i];

left[i]=-2;

printf("%d to right\n",i);

}

}

}

void rtol(int left[],int right[])

//从对岸回去时选一个元素

{

int i;

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

if(abs(right[(i+1)%3]-right[(i+2)%3])==1)

//如果有两数之差有绝对值为一的情况，说明人必须带回一个元素回去，不然有吃东西会被吃掉

{

left[(i+1)%3]=right[(i+1)%3];

right[(i+1)%3]=-2;

printf("%d to left\n",i+1);

}

}

void main()

{

int left[3]={0,1,2},right[4]={-2,-2,-2};

while(!kong(left))

{

ltor(left,right);

if(!kong(left))

rtol(left,right);

}

}

//这是我学时参照的程序希望对你有帮助

#include<stdioh>

#define m 3

#define n 3

int main() {

int a[m][n],i,j,max,min,flag=0,i1;

printf("请输入二维数组a[%d][%d]:\n",m,n);

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

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

scanf("%d",&a[i][j]);

printf("二维数组a[%d][%d]如下:\n",m,n);

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

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

printf("%4d",a[i][j]);

printf("\n");

}

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

i1=i;

for (max=a[i][0],j=0;j<n;j++) ####### max=a[i][j]改max=a[i][0]

if (max<a[i][j])

max=a[i][j];

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

for (min=a[i][j],i=0;i<m;i++)

if (min>a[i][j])

min=a[i][j];

i=i1;

if (a[i][j]==max&&a[i][j]==min) {

printf("a[%d][%d]=%d ",i,j,a[i][j]);

flag++;

}

}

}

if (flag==0)

printf("没有鞍点!\n");

else printf("\n");

}

请输入二维数组a[3][3]:

1

2

3

4

5

6

7

8

9

二维数组a[3][3]如下:

1 2 3

4 5 6

7 8 9

a[0][2]=3

以上就是关于用c语言编写一个程序，实现一个简单的冒泡排序算法全部的内容，包括:用c语言编写一个程序，实现一个简单的冒泡排序算法、怒了，求高人解释程序算法，很简短的一个程序、编一程序用简单选择排序方法对n个整数排序（从大到小）。 对n个数进行降序排列，简单选择排序的算法思等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！