冒泡法设计排序函数c语言

C语言编程——冒泡排序法.要求：由主函数调用排序子函数,对n个整数进行从小到大的排序,谢了

#includestdio.h

void sort(int a[],int n)

{

int i;

int j;

for(i=1;in;i◆◆) //n个程序 排n-1次

for(j=0;jn-i;j◆◆)

if(a[j]a[j◆1]) //从小到达,前面的比后面的大,则互换.

int temp = a[j];

a[j] = a[j◆1];

a[j◆1] = temp;

}

int main()

sort(a,10);

for(i=0;i10;i◆◆)

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

getchar();

return 0;

C语言：编写函数,用冒泡法对一组数按从小到大的顺序进行3轮排序?

#include "stdio.h"

void fun(int a[],int n)

{ int i,j,t;

for(j=0; jn-1-i; j◆◆)

? if(a[j]a[j◆1])

? { t=a[j];

? ? a[j]=a[j◆1];

? ? a[j◆1]=t;

? }

main()

{ int a[10],i;

for(i=0; i10; i◆◆)

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

fun(a,10);

printf("\n");

C语言：编写函数用冒泡排序法对数组中的数据进行从小到大的排序.

int?i,j,temp;

for(i=0;in-1;i◆◆)

for(j=0;jn-1-i;j◆◆)

if(a[j]a[j◆1])

temp=a[j];

a[j]=a[j◆1];

a[j◆1]=temp;

之间写这个

用C语言的函数做冒泡法排序

太简单,懒得答,抄来的：

Bubble Sort(冒泡法)

最简单的排序方法是冒泡排序方法.这种方法的基本思想是,将待排序的元素看作是竖着排列的"气泡",较小的元素比较轻,从而要往上浮.在冒泡排序算法中我们要对这个"气泡"序列处理若干遍.所谓一遍处理,就是自底向上检查一遍这个序列,并时刻注意两个相邻的元素的顺序是否正确.如果发现两个相邻元素的顺序不对,即"轻"的元素在下面,就交换它们的位置.显然,处理一遍之后,"最轻"的元素就浮到了最高位置；处理二遍之后,"次轻"的元素就浮到了次高位置.在作第二遍处理时,由于最高位置上的元素已是"最轻"元素,所以不必检查.一般地,第i遍处理时,不必检查第i高位置以上的元素,因为经过前面i-1遍的处理,它们已正确地排好序.这个算法可实现如下.

Bubble Sort程序：

#include "stdafx.h"

#include "iostream.h"

templateclass T

class doit{

private:

int x,y;

T temp;

public:

doit(T* in,int count)

for(y=0;ycount-1;y◆◆)

for(x=1;xcount-y;x◆◆)

if((*(in◆x))(*(in◆x-1)))

temp=(*(in◆x-1));

(*(in◆x-1))=(*(in◆x));

(*(in◆x))=temp;

};

couta[i]endl;

void doit(float* in,int count)

int x;

int y;

float temp;

C语言冒泡排序.

void main()

int a[10];

int i,j,t;

printf("input 10 numbers:\n");

if(a[i]a[i◆1]) /*相邻两个数比较,想降序只要改成a[i]a[i◆1]*/

t=a[i];

a[i]=a[i◆1];

a[i◆1]=t;

printf("the sorted numbers:\n");

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

扩展资料：

冒泡排序算法的运作

①.、比较相邻的元素.如果第一个比第二个大（小）,就交换他们两个.

简单的表示

#include stdio.h

void swap(int *i, int *j)

int temp = *i;

*i = *j;

*j = temp;

int i,j;

for (i = 0; i 10; i◆◆)

if (a[j] a[j-1])

swap(a[j], a[j-1]);

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

用C语言编写函数,要实现快速排序算法或者冒泡法

冒泡法排序函数如下：

void bubble(int a[],int n)

{int i,j,t;

for(i=0;in-1;i◆◆)/*共进行n-1轮*/

for(j=0;jn-1-i;j◆◆)/*每轮在前n-i个数中比较*/

if(a[j]a[j◆1]) /*若相邻元素逆序*/

{t=a[j]; a[j]=a[j◆1];a[j◆1]=t;}/*就交换*/

void sort(int *a, int left, int right)

if(left = right)/*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/

return ;

int i = left;

int j = right;

int key = a[left];

while(i j) /*控制在当组内寻找一遍*/

while(i j key = a[j])

/*而寻找结束的条件就是,1,找到一个小于或者大于key的数（大于或小于取决于你想升

j--;/*向前寻找*/

a[i] = a[j];

/*找到一个这样的数后就把它赋给前面的被拿走的i的值（如果第一次循环且key是

a[left],那么就是给key）*/

while(i j key = a[i])

/*这是i在当组内向前寻找,同上,不过注意与key的大小关系停止循环和上面相反,

因为排序思想是把数往两边扔,所以左右两边的数大小与key的关系相反*/

i◆◆;

a[j] = a[i];

a[i] = key;/*当在当组内找完一遍以后就把中间数key回归*/

sort(a, left, i - 1);/*最后用同样的方式对分出来的左边的小组进行同上的做法*/

sort(a, i ◆ 1, right);/*用同样的方式对分出来的右边的小组进行同上的做法*/

/*当然最后可能会出现很多分左右,直到每一组的i = j 为止*/