一 : C++编程编写一个冒泡排序的函数模板，并用它分别对int型和字符

C++编程

编写一个冒泡排序的模板，并用它分别对int型和字符数据进行排序

---

#include#include/*

这是一个起泡排序的模板

输入：data 待排序数组 ，

size 数组大小

输出：排序后数组

其他说明：

数据类型T应支持<和 =

10/6/2006 coded by YunDanFengQing

*/

templatevoid BubbleSort ( T * data, int size )

{

bool swapped = false;

T temp;

do {

swapped = false;

for ( int i = 0; i

if ( data[ i+1 ]

temp = data[ i+1 ];

data[ i+1 ] = data [ i ];

data[ i ] = temp;

swapped = true;

}

}

}while ( true == swapped );

}// BubbleSort

int main()

{

int i = 0;

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

std::string s[11] = { "aaaa", "aaba", "abcd", "bcded", "aaab", "yuooo", "aacd", "aaca",

"aaac", "aazs", "desed" };

BubbleSort ( a , 10 );

BubbleSort ( s , 11 );

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

std::cout<<"a[ "<

return 0;

}

二 : C语言冒泡排序法的简单程序

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

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

if (a[i]>a[i+1])

{ temp=a[i];

a[i]=a[i+1];

a[i+1]=temp;}

}

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

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

printf("n");

}

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

冒泡算法

冒泡排序的算法分析与改进

交换排序的基本思想是：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。［www.61k.com）

应用交换排序基本思想的主要排序方法有：冒泡排序和快速排序。

冒泡排序

1、排序方法

将被排序的记录数组R[1..n]垂直排列，每个记录R看作是重量为R.key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。

（1）初始

R[1..n]为无序区。

（2）第一趟扫描

从无序区底部向上依次比较相邻的两个气泡的重量，若发现轻者在下、重者在上，则交换二者的位置。即依次比较(R[n]，R[n-1])，(R[n-1]，R[n-2])，…，(R[2]，R[1])；对于每对气泡(R[j+1]，R[j])，若R[j+1].key<R[j].key，

冒泡排序法 C语言冒泡排序法的简单程序

则交换R[j+1]和R[j]的内容。(www.61k.com］

第一趟扫描完毕时，"最轻"的气泡就飘浮到该区间的顶部，即关键字最小的记录被放在最高位置R[1]上。

（3）第二趟扫描

扫描R[2..n]。扫描完毕时，"次轻"的气泡飘浮到R[2]的位置上……

最后，经过n-1 趟扫描可得到有序区R[1..n]

注意：

第i趟扫描时，R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时，该区中最轻气泡飘浮到顶部位置R上，结果是R[1..i]变为新的有序区。

2、冒泡排序过程示例

对关键字序列为49 38 65 97 76 13 27 49的文件进行冒泡排序的过程

3、排序算法

（1）分析

因为每一趟排序都使有序区增加了一个气泡，在经过n-1趟排序之后，有序区中就有n-1个气泡，而无序区中气泡的重量总是大于等于有序区中气泡的重量，所以整个冒泡排序过程至多需要进行n-1趟排序。 若在某一趟排序中未发现气泡位置的交换，则说明待排序的无序区中所有气泡均满足轻者在上，重者在下的原则，因此，冒泡排序过程可在此趟排序后终止。为此，在下面给出的算法中，引入一个布尔量exchange，在每趟排序开始前，先将其置为FALSE。若排序过程中发生了交换，则将其置为TRUE。各趟排序结束时检查exchange，若未曾发生过交换则终止算法，不再进行下一趟排序。

（2）具体算法

void BubbleSort(SeqList R)

{ //R（l..n)是待排序的文件，采用自下向上扫描，对R做冒泡排序

int i，j；

Boolean exchange； //交换标志

for(i=1;i<n;i++){ //最多做n-1趟排序

exchange=FALSE； //本趟排序开始前，交换标志应为假

for(j=n-1;j>=i；j--) //对当前无序区R[i..n]自下向上扫描

if(R[j+1].key<R[j].key){//交换记录

R[0]=R[j+1]； //R[0]不是哨兵，仅做暂存单元

R[j+1]=R[j]；

R[j]=R[0]；

exchange=TRUE； //发生了交换，故将交换标志置为真

}

if(!exchange) //本趟排序未发生交换，提前终止算法

return；

} //endfor(外循环)

} //BubbleSort

4、算法分析

（1）算法的最好时间复杂度

若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数M均达到最小值：

冒泡排序法 C语言冒泡排序法的简单程序

Cmin=n-1

Mmin=0。［www.61k.com］

冒泡排序最好的时间复杂度为O(n)。

（2）算法的最坏时间复杂度

若初始文件是反序的，需要进行n-1趟排序。每趟排序要进行n-i次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：

Cmax=n(n-1)/2=O(n2)

Mmax=3n(n-1)/2=O(n2)

冒泡排序的最坏时间复杂度为O(n2)。

（3）算法的平均时间复杂度为O(n2)

虽然冒泡排序不一定要进行n-1趟，但由于它的记录移动次数较多，故平均时间性能比直接插入排序要差得多。

（4）算法稳定性

冒泡排序是就地排序，且它是稳定的。

5、算法改进

上述的冒泡排序还可做如下的改进：

(1)记住最后一次交换发生位置lastExchange的冒泡排序

在每趟扫描中，记住最后一次交换发生的位置lastExchange，（该位置之前的相邻记录均已有序）。下一趟排序开始时，R[1..lastExchange-1]是有序区，R[lastExchange..n]是无序区。这样，一趟排序可能使当前有序区扩充多个记录，从而减少排序的趟数。具体算法【参见习题】。

(2) 改变扫描方向的冒泡排序

①冒泡排序的不对称性

能一趟扫描完成排序的情况：

只有最轻的气泡位于R[n]的位置，其余的气泡均已排好序，那么也只需一趟扫描就可以完成排序。

【例】对初始关键字序列12，18，42，44，45，67，94，10就仅需一趟扫描。

需要n-1趟扫描完成排序情况：

当只有最重的气泡位于R[1]的位置，其余的气泡均已排好序时，则仍需做n-1趟扫描才能完成排序。

【例】对初始关键字序列：94，10，12，18，42，44，45，67就需七趟扫描。

②造成不对称性的原因

每趟扫描仅能使最重气泡"下沉"一个位置，因此使位于顶端的最重气泡下沉到底部时，需做n-1趟扫描。

③改进不对称性的方法

在排序过程中交替改变扫描方向，可改进不对称性。

回答者：cicihsk - 助理 二级 9-4 11:08

评价已经被关闭 目前有 4 个人评价

好

75% （3） 不好 25% （1）

冒泡排序法 C语言冒泡排序法的简单程序

其他回答 共 3 条

main()

{int i,j,n,a[10];

printf("输入10个数:");

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

scanf("%d,",&a[i]);//记得输入的时候后面加“，” for(i=0;i<n-1;i++)

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

if(a[i]>a[j]) //改成(a[i]<a[j])可按大到小排序 { n=a[i];a[i]=a[j];a[j]=a[i]；}

printf("n由小到大排序结果为："）; for(i=0;i<10;i++)

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

}

转载自 非常代码网

/* Function Prototypes */

void BubbleSort( int Array[], const int Size );

void PrintArray( int Array[], const int Size );

int main( void )

{

int i;

const int Size = 20;

int Array[ Size ];

/* Fill the Array with random values

between 0 and 99 */

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

Array[i] = random() % 100;

/* Print the Random Array to Screen */ 回答者：TANK006 - 经理 四级 9-4 11:06

冒泡排序法 C语言冒泡排序法的简单程序

clrscr();

printf( "The Array with random order:nn");

PrintArray( Array, Size );

/* Wait for key Press... */

printf( "nPress any key..." );

getch();

/* Sort the Array using Bubble Sort */

BubbleSort( Array, Size );

/* Print the Smallest-to-Largest

Order Array */

clrscr();

printf( "The Array after Bubble Sort:nn");

PrintArray( Array, Size );

/* End the Program */

printf( "nPress any key to quit..." );

getch();

return 0;

}

/* Uses the classic bubble sort algorithm */

void BubbleSort( int Array[], const int Size )

{

冒泡排序法 C语言冒泡排序法的简单程序

int i, j, temp;

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

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

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

{

temp = Array[j];

Array[j] = Array[j + 1];

Array[j + 1] = temp;

}

}

/* Prints an integer Array line by line */

void PrintArray( int Array[], const int Size )

{

int i;

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

printf("Array[%i] = %in", i, Array[i] );

1. 有 N 个人围成一圈参加游戏，游戏的规则是： 所有出场的编号都会满足一个条件，即:（编号＋N）%M＝0，这样子用一个数组就可以解决这个问题了

N个人的编号分别为1、2、……、N，以编号为‘1’的人开始报数，报到 M 时该人跳出圈子,下一人继续报数。[www.61k.com)按此要求依次输出所有跳出圈子人员的编号。

struct test{

int num;

冒泡排序法 C语言冒泡排序法的简单程序

int flag;

};

static int N =20;

static int M =30;

int main()

{

struct test test1[N+1];

int j=1,i=1,k=0,none=0,line=0;

memset(test1,0,sizeof(test1));

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

{

test1[i].num=i;

test1[i].flag=1;

}

j=1;

i=0;

while(1)

{

none=0;

if(i++> =N)i=1;

if(test1[i].flag)

{

if(j++==M&&(j=1))

{

printf( "%d ",test1[i].num); if(++line%10==0)printf( "n "); test1[i].flag=0;

for(k=1;k <=N;k++)

if(test1[k].flag){none=1;break;} if(!none){printf( "n ");return 0;} }

}

}

}

这个是传统约瑟夫问题。［www.61k.com］。~我有类似的！~ #include<stdio.h>

void main()

{

int s=0,n,k,i,ren=0,t,b;//REN来统计人数， int r[101];

scanf("%d",&n); scanf("%d",&k);

冒泡排序法 C语言冒泡排序法的简单程序

for(i=1;i<=n;i++)r[i]=1;

i=1;

t=n;

b=k%t;//报的数太大时，可以用求模

while(ren<n-1)

{

s+=r[i]; //S相当报的数，每人加一，死了是0；

if(k%t==0)b=k;

else b=k%t;

if(s%b==0)

{

if (r[i])

{

printf("%dn",i);//i是他的标号

ren++;

t=t-1;}//如果r[i]＝0，REN就不＋＋，因为他已经死过啦！

r[i]=0;

s=0;

}

i++;

if(i>n) i=1;//超过了就重头来咯~~嘿嘿~~

}

}

2. 已知一维数组 A 共有25个元素，值为：A(I)=I，现将此一维数组存入二维数组 B(5,5)，存放次序为：

A(1) A(2) A(5) A(10) A(17)

A(4) A(3) A(6) A(11) A(18)

A(9) A(8) A(7) A(12) A(19)

A(16) A(15) A(14) A(13) A(20)

A(25) A(24) A(23) A(22) A(21)

即：

B(1,1)=A(1) B(1,2)=A(2) B(1,3)=A(5) B(1,4)=A(10) B(1,5)=A(17)… #define line 5

int main()

{

int a[line*line],b[line][line];

int i=0,j=0,k=0,m=0;

for(i=0;i <line*line;i++)

a[i]=i;

冒泡排序法 C语言冒泡排序法的简单程序

memset(b,0,sizeof(b));

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

{

for(j=0,k=i;j <=i;j++)

{

b[j][k]=a[m++];

}

for(k=i-1,j=i;k> =0;k--)

{

b[j][k]=a[m++];

}

}

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

{

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

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

printf( "n ");

}

}

3. 在屏幕上输出杨辉三角形的前 N 1

1 1

1 2 1

1 3 3 1 1 4 6 4 1 5 10 10 1 6 15 20 1 7 21 35 程序源代码：

main()

{int i,j;

int a[10][10];

printf( "n ");

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

{a[i][0]=1;

a[i][i]=1;}

for(i=2;i <10;i++)

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

a[i][j]=a[i-1][j-1]+a[i-1][j]; for(i=0;i <10;i++)

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

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

printf( "n ");

} 行: 1 5 1 15 6 35 21 1 7 1

冒泡排序法 C语言冒泡排序法的简单程序

}

第三题:

#define N 10

int main()

{

int i=0,j=0,k=0,m=0,n=0;

int linenum=10,buf1[N+1],buf2[N+1];

memset(buf1,0,sizeof(buf1));

memset(buf2,0,sizeof(buf2));

buf1[1]=1;

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

{

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

{

printf( "%d ",buf2[j]=buf1[j-1]+buf1[j]);

}

memset(buf1,0,sizeof(buf1));

memcpy(buf1,buf2,sizeof(buf1));

memset(buf2,0,sizeof(buf2));

printf( "n ");

}

}

4. 魔术矩阵问题：魔术矩阵由一个n×n(n为奇数)的整数矩阵构成，矩阵中的整数

值是从1～n2 。(www.61k.com] 每一行、每一列和两个对角线上数值之和相等。例如下面n为5的 魔术矩阵，它的和是65：

15 8 1 24 17

16 14 7 5 23

22 20 13 6 4

3 21 19 12 10

9 2 25 18 11

:

#include <stdio.h>

main()

{

int a[100][100]={0},i,j,k,n;

printf( "程序最大能够输出99以内的魔方阵,但为了直观,请输入n阶魔方阵3~19(奇数):n "); for (;;)

{

scanf( "%d ",&n);

if (n%2==0)

continue;

else break;

冒泡排序法 C语言冒泡排序法的简单程序

}

a[0][n/2]=1;

for (k=2,i=0,j=n/2;k <=n*n;k++) {

if (i==0&&j==n-1)

{

a[++i][j]=k;

k++;

}

if (i==0)

i=n-1;

else i=--i;

if (j==n-1)

j=0;

else j=++j;

if (a[i][j]!=0)

a[i=i+2][j=--j]=k;

else a[i][j]=k;

}

printf( "%d阶魔方阵为:n ",n); for (i=0;i <n;i++)

{

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

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

printf( "n ");

}

}

三 : C语言冒泡排序法的简单程序

求一个C语言冒泡排序法的简单程序

悬赏分：50 - 解决时间：2007-9-4 11:16

我不明白怎么写

随便给我个就行

谢谢了

提问者： redangel0002 - 助理 二级 最佳答案

main()

{

int i,j,temp;

int a[10];

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

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

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

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

if (a[i]>a[i+1])

{ temp=a[i];

a[i]=a[i+1];

a[i+1]=temp;}

}

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

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

printf("n");

}

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

冒泡算法

冒泡排序的算法分析与改进

交换排序的基本思想是：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。

应用交换排序基本思想的主要排序方法有：冒泡排序和快速排序。

冒泡排序

1、排序方法

将被排序的记录数组R[1..n]垂直排列，每个记录R看作是重量为R.key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。

（1）初始

R[1..n]为无序区。

（2）第一趟扫描

从无序区底部向上依次比较相邻的两个气泡的重量，若发现轻者在下、重者在上，则交换二者的位置。即依次比较(R[n]，R[n-1])，(R[n-1]，R[n-2])，…，(R[2]，R[1])；对于每对气泡(R[j+1]，R[j])，若R[j+1].key<R[j].key，

则交换R[j+1]和R[j]的内容。

第一趟扫描完毕时，"最轻"的气泡就飘浮到该区间的顶部，即关键字最小的记录被放在最高位置R[1]上。

（3）第二趟扫描

扫描R[2..n]。扫描完毕时，"次轻"的气泡飘浮到R[2]的位置上……

最后，经过n-1 趟扫描可得到有序区R[1..n]

注意：

第i趟扫描时，R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时，该区中最轻气泡飘浮到顶部位置R上，结果是R[1..i]变为新的有序区。

2、冒泡排序过程示例

对关键字序列为49 38 65 97 76 13 27 49的文件进行冒泡排序的过程

3、排序算法

（1）分析

因为每一趟排序都使有序区增加了一个气泡，在经过n-1趟排序之后，有序区中就有n-1个气泡，而无序区中气泡的重量总是大于等于有序区中气泡的重量，所以整个冒泡排序过程至多需要进行n-1趟排序。 若在某一趟排序中未发现气泡位置的交换，则说明待排序的无序区中所有气泡均满足轻者在上，重者在下的原则，因此，冒泡排序过程可在此趟排序后终止。为此，在下面给出的算法中，引入一个布尔量exchange，在每趟排序开始前，先将其置为FALSE。若排序过程中发生了交换，则将其置为TRUE。各趟排序结束时检查exchange，若未曾发生过交换则终止算法，不再进行下一趟排序。

（2）具体算法

void BubbleSort(SeqList R)

{ //R（l..n)是待排序的文件，采用自下向上扫描，对R做冒泡排序

int i，j；

Boolean exchange； //交换标志

for(i=1;i<n;i++){ //最多做n-1趟排序

exchange=FALSE； //本趟排序开始前，交换标志应为假

for(j=n-1;j>=i；j--) //对当前无序区R[i..n]自下向上扫描

if(R[j+1].key<R[j].key){//交换记录

R[0]=R[j+1]； //R[0]不是哨兵，仅做暂存单元

R[j+1]=R[j]；

R[j]=R[0]；

exchange=TRUE； //发生了交换，故将交换标志置为真

}

if(!exchange) //本趟排序未发生交换，提前终止算法

return；

} //endfor(外循环)

} //BubbleSort

4、算法分析

（1）算法的最好时间复杂度

若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数M均达到最小值：

Cmin=n-1

Mmin=0。

冒泡排序最好的时间复杂度为O(n)。

（2）算法的最坏时间复杂度

若初始文件是反序的，需要进行n-1趟排序。每趟排序要进行n-i次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：

Cmax=n(n-1)/2=O(n2)

Mmax=3n(n-1)/2=O(n2)

冒泡排序的最坏时间复杂度为O(n2)。

（3）算法的平均时间复杂度为O(n2)

虽然冒泡排序不一定要进行n-1趟，但由于它的记录移动次数较多，故平均时间性能比直接插入排序要差得多。

（4）算法稳定性

冒泡排序是就地排序，且它是稳定的。

5、算法改进

上述的冒泡排序还可做如下的改进：

(1)记住最后一次交换发生位置lastExchange的冒泡排序

在每趟扫描中，记住最后一次交换发生的位置lastExchange，（该位置之前的相邻记录均已有序）。下一趟排序开始时，R[1..lastExchange-1]是有序区，R[lastExchange..n]是无序区。这样，一趟排序可能使当前有序区扩充多个记录，从而减少排序的趟数。具体算法【参见习题】。

(2) 改变扫描方向的冒泡排序

①冒泡排序的不对称性

能一趟扫描完成排序的情况：

只有最轻的气泡位于R[n]的位置，其余的气泡均已排好序，那么也只需一趟扫描就可以完成排序。

【例】对初始关键字序列12，18，42，44，45，67，94，10就仅需一趟扫描。

需要n-1趟扫描完成排序情况：

当只有最重的气泡位于R[1]的位置，其余的气泡均已排好序时，则仍需做n-1趟扫描才能完成排序。

【例】对初始关键字序列：94，10，12，18，42，44，45，67就需七趟扫描。

②造成不对称性的原因

每趟扫描仅能使最重气泡"下沉"一个位置，因此使位于顶端的最重气泡下沉到底部时，需做n-1趟扫描。

③改进不对称性的方法

在排序过程中交替改变扫描方向，可改进不对称性。

回答者：cicihsk - 助理 二级 9-4 11:08

评价已经被关闭 目前有 4 个人评价

好

75% （3） 不好 25% （1）

其他回答 共 3 条

main()

{int i,j,n,a[10];

printf("输入10个数:");

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

scanf("%d,",&a[i]);//记得输入的时候后面加“，” for(i=0;i<n-1;i++)

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

if(a[i]>a[j]) //改成(a[i]<a[j])可按大到小排序 { n=a[i];a[i]=a[j];a[j]=a[i]；}

printf("n由小到大排序结果为："）; for(i=0;i<10;i++)

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

}

转载自 非常代码网

/* Function Prototypes */

void BubbleSort( int Array[], const int Size );

void PrintArray( int Array[], const int Size );

int main( void )

{

int i;

const int Size = 20;

int Array[ Size ];

/* Fill the Array with random values

between 0 and 99 */

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

Array[i] = random() % 100;

/* Print the Random Array to Screen */ 回答者：TANK006 - 经理 四级 9-4 11:06

clrscr();

printf( "The Array with random order:nn");

PrintArray( Array, Size );

/* Wait for key Press... */

printf( "nPress any key..." );

getch();

/* Sort the Array using Bubble Sort */

BubbleSort( Array, Size );

/* Print the Smallest-to-Largest

Order Array */

clrscr();

printf( "The Array after Bubble Sort:nn");

PrintArray( Array, Size );

/* End the Program */

printf( "nPress any key to quit..." );

getch();

return 0;

}

/* Uses the classic bubble sort algorithm */

void BubbleSort( int Array[], const int Size )

{

int i, j, temp;

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

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

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

{

temp = Array[j];

Array[j] = Array[j + 1];

Array[j + 1] = temp;

}

}

/* Prints an integer Array line by line */

void PrintArray( int Array[], const int Size )

{

int i;

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

printf("Array[%i] = %in", i, Array[i] );

1. 有 N 个人围成一圈参加游戏，游戏的规则是： 所有出场的编号都会满足一个条件，即:（编号＋N）%M＝0，这样子用一个数组就可以解决这个问题了

N个人的编号分别为1、2、……、N，以编号为‘1’的人开始报数，报到 M 时该人跳出圈子,下一人继续报数。按此要求依次输出所有跳出圈子人员的编号。

struct test{

int num;

int flag;

};

static int N =20;

static int M =30;

int main()

{

struct test test1[N+1];

int j=1,i=1,k=0,none=0,line=0;

memset(test1,0,sizeof(test1));

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

{

test1[i].num=i;

test1[i].flag=1;

}

j=1;

i=0;

while(1)

{

none=0;

if(i++> =N)i=1;

if(test1[i].flag)

{

if(j++==M&&(j=1))

{

printf( "%d ",test1[i].num); if(++line%10==0)printf( "n "); test1[i].flag=0;

for(k=1;k <=N;k++)

if(test1[k].flag){none=1;break;} if(!none){printf( "n ");return 0;} }

}

}

}

这个是传统约瑟夫问题。。~我有类似的！~ #include<stdio.h>

void main()

{

int s=0,n,k,i,ren=0,t,b;//REN来统计人数， int r[101];

scanf("%d",&n); scanf("%d",&k);

for(i=1;i<=n;i++)r[i]=1;

i=1;

t=n;

b=k%t;//报的数太大时，可以用求模

while(ren<n-1)

{

s+=r[i]; //S相当报的数，每人加一，死了是0；

if(k%t==0)b=k;

else b=k%t;

if(s%b==0)

{

if (r[i])

{

printf("%dn",i);//i是他的标号

ren++;

t=t-1;}//如果r[i]＝0，REN就不＋＋，因为他已经死过啦！

r[i]=0;

s=0;

}

i++;

if(i>n) i=1;//超过了就重头来咯~~嘿嘿~~

}

}

2. 已知一维数组 A 共有25个元素，值为：A(I)=I，现将此一维数组存入二维数组 B(5,5)，存放次序为：

A(1) A(2) A(5) A(10) A(17)

A(4) A(3) A(6) A(11) A(18)

A(9) A(8) A(7) A(12) A(19)

A(16) A(15) A(14) A(13) A(20)

A(25) A(24) A(23) A(22) A(21)

即：

B(1,1)=A(1) B(1,2)=A(2) B(1,3)=A(5) B(1,4)=A(10) B(1,5)=A(17)… #define line 5

int main()

{

int a[line*line],b[line][line];

int i=0,j=0,k=0,m=0;

for(i=0;i <line*line;i++)

a[i]=i;

memset(b,0,sizeof(b));

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

{

for(j=0,k=i;j <=i;j++)

{

b[j][k]=a[m++];

}

for(k=i-1,j=i;k> =0;k--)

{

b[j][k]=a[m++];

}

}

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

{

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

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

printf( "n ");

}

}

3. 在屏幕上输出杨辉三角形的前 N 1

1 1

1 2 1

1 3 3 1 1 4 6 4 1 5 10 10 1 6 15 20 1 7 21 35 程序源代码：

main()

{int i,j;

int a[10][10];

printf( "n ");

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

{a[i][0]=1;

a[i][i]=1;}

for(i=2;i <10;i++)

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

a[i][j]=a[i-1][j-1]+a[i-1][j]; for(i=0;i <10;i++)

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

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

printf( "n ");

} 行: 1 5 1 15 6 35 21 1 7 1

}

第三题:

#define N 10

int main()

{

int i=0,j=0,k=0,m=0,n=0;

int linenum=10,buf1[N+1],buf2[N+1];

memset(buf1,0,sizeof(buf1));

memset(buf2,0,sizeof(buf2));

buf1[1]=1;

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

{

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

{

printf( "%d ",buf2[j]=buf1[j-1]+buf1[j]);

}

memset(buf1,0,sizeof(buf1));

memcpy(buf1,buf2,sizeof(buf1));

memset(buf2,0,sizeof(buf2));

printf( "n ");

}

}

4. 魔术矩阵问题：魔术矩阵由一个n×n(n为奇数)的整数矩阵构成，矩阵中的整数

值是从1～n2 。 每一行、每一列和两个对角线上数值之和相等。例如下面n为5的 魔术矩阵，它的和是65：

15 8 1 24 17

16 14 7 5 23

22 20 13 6 4

3 21 19 12 10

9 2 25 18 11

:

#include <stdio.h>

main()

{

int a[100][100]={0},i,j,k,n;

printf( "程序最大能够输出99以内的魔方阵,但为了直观,请输入n阶魔方阵3~19(奇数):n "); for (;;)

{

scanf( "%d ",&n);

if (n%2==0)

continue;

else break;

}

a[0][n/2]=1;

for (k=2,i=0,j=n/2;k <=n*n;k++) {

if (i==0&&j==n-1)

{

a[++i][j]=k;

k++;

}

if (i==0)

i=n-1;

else i=--i;

if (j==n-1)

j=0;

else j=++j;

if (a[i][j]!=0)

a[i=i+2][j=--j]=k;

else a[i][j]=k;

}

printf( "%d阶魔方阵为:n ",n); for (i=0;i <n;i++)

{

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

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

printf( "n ");

}

}

本文标题：c语言编程冒泡法排序-C++编程编写一个冒泡排序的函数模板，并用它分别对int型和字符
本文地址： http://www.61k.com/1155294.html