⑴ c语言中冒泡排序法（又称起泡排序法）得具体程序
冒泡法我是这样理解的，便于掌握和记忆。首先冒泡是n长度的数组开始的两位开始，逐位双双比较一直到最后两个，所以最外循环比较了n-1次。第一个数比较了以后就不比了，从第二个开始，一直比较到数组末尾，于是内循环的起始位置不同，每次都是外侧i的值加0，也就是i。但结束的限制和外层循环是相同的。于是写法为for (i=0;i<n-1;i++)
{
for(j=i;j<n-1;j++)
⑵ 急！！求c语言单链表冒泡排序的详细流程图
#include<stdio.h> #include<malloc.h> struct number { int num; struct number *next; }; void main() { struct number *head; struct number *p1,*p2,*p,*p3,*p4; int n=0,m,i,j; p1=p2=(struct number *)malloc(sizeof(struct number)); printf("\nWang jianfei 060806110006\n\n\n"); printf("Please enter the number: \n"); scanf("%d",&p1->num); head=NULL; while(p1->num!=NULL) { n=n+1; if(head==NULL) head=p1; else p2->next=p1; p2=p1; p1=(struct number *)malloc(sizeof(struct number)); scanf("%d",&p1->num); } p2->next=NULL; p=head; for(p4=head;p4!=NULL;p4=p4->next) { for(p3=head;p3->next!=NULL;p3=p3->next) { if(p4->num>p3->num) { m=p4->num; p4->num=p3->num; p3->num=m; } } p=head; } printf("\nNow,there %d numbers are: ",n); p=head; printf("\n"); if(head!=NULL) do { printf("%5d ",p->num); p=p->next; }while(p!=NULL); printf("\n"); getch(); }
⑶ 排序算法的设计（c语言）根据程序画流程图及对每句程序加注释
#include "stdio.h"//标准io头文件
#include "stdlib.h"//库文件
#include "time.h"//时间系头文件
#define N0 100000 //定义常量
typedef int keytype; //类型命名
typedef struct node //定义结构体
{ keytype key; //只是类型命名成keytype，其实就是int的
}Etp;//结构体类型叫做Etp
Etp R[N0+1]; // R[1]..R[n] //定义数组
int n=50, count;//全局变量
void readData( Etp R[], int n)//读数据的函数
{ int i;
count=0;
srand( time( NULL ));//初始化时间种子
for( i=1; i<=n; i++) //对数组初始化
R[i].key=1000+
(int)((9999.0-1000)*rand()/RAND_MAX); // 0..RAND_MAX
}
void printData( Etp R[], int n )//打印显示数据的函数
{ int i;
for( i=1; i<=n; i++)
printf("%8d%s", //格式化显示数组的数据
R[i].key, i%5==0?"\n":"");
printf("\ncount=%d\n", count);
}
void bubberSort( Etp R[], int n )//冒泡排序的函数
{ int i,j;//（这个函数块就是冒泡排序的算法程序）
bool swap;
for( i=1; i<=n-1; i++)
{ swap=false;
for( j=1; j<=n-i; j++)
if( count++,R[j].key>R[j+1].key )
{ R[0]=R[j];
R[j]=R[j+1];
R[j+1]=R[0];
swap=true;
}
if( !swap ) break;
}
}
void bubberSort1( Etp R[], int n )//这个也是另一个冒泡排序的函数
{ int j;//跟上面不同的是这个算法用的是递归的方式，上面的是非递归的
for( j=1; j<=n-1; j++)
if( count++,R[j].key>R[j+1].key )
{ R[0]=R[j];
R[j]=R[j+1];//________;//就是两个变量交换值
R[j+1]=R[0];
}
if( n>1 ) bubberSort1( R, n-1); //___________;//递归调用
}
void selectSort( Etp R[], int n )//这个是选择排序
{ int i,j,k;//（这个函数块就是选择排序的算法程序）
for( i=1; i<=n-1; i++)
{
k=i;
for( j=i+1; j<=n; j++)
if( count++,R[j].key<R[k].key ) k=j;
if( k!=i )
{ R[0]=R[i];
R[i]=R[k];
R[k]=R[0];
}
}
}
void insertSort( Etp R[], int n )//这个是插入排序
{ int i,j;
for( i=2; i<=n; i++)
{
R[0]=R[i];
j=i-1;
while( count++,R[j].key>R[0].key ) R[j+1]=R[j--];
R[j+1]=R[0];
count++;
}
}
void sift( Etp R[], int i, int m)//堆排序中的步骤
{ int k=2*i;
R[0]=R[i];
while( k<=m )
{ if( count++, k+1<=m && R[k+1].key>R[k].key) k++;
if( count++,R[0].key<R[k].key ) R[i]=R[k];
else break;
i=k;
k=2*i;
}
R[i]=R[0];
}
void heapSort( Etp R[], int n )//这个是堆排序
{ int j;
for( j=n/2; j>=1; j--) sift( R, j, n);
for( j=n; j>=2; j--)
{ R[0]=R[1];
R[1]=R[j];
R[j]=R[0];
sift( R, 1, j-1 );
}
}
int main()//主函数的进入口
{
readData( R, n );//读取数据
bubberSort1( R, n );//调用递归冒泡排序
printData( R, n);//显示数据
readData( R, n );//读取数据
selectSort( R, n );//调用选择排序
printData( R, n);//显示数据
readData( R, n );//读取数据
insertSort( R, n );//调用插入排序
printData( R, n);//显示数据
readData( R, n );//读取数据
heapSort( R, n );//调用堆排序
printData( R, n);//显示数据
return 0;
}
//诶·~注释完我总算看出来了，难道你要我解释各个排序的过程？
//那你还不如直接或者看书，你要是不理解原理是不可能看懂过程的。
//注释也只是语句的解释，但是过程的含义是无法描述的
⑷ C语言冒泡排序法是什么
冒泡排序法，是C语言常用的排序算法之一，意思是对一组数字进行从大到小或者从小到大排序的一种算法。
具体方法是：
相邻数值两两交换。从第一个数值开始，如果相邻两个数的排列顺序与我们的期望不同，则将两个数的位置进行交换（对调）；如果其与我们的期望一致，则不用交换。重复这样的过程，一直到最后没有数值需要交换，则排序完成。
C语言常见的排序算法：
1、冒泡排序
基本思想：比较相邻的两个数，如果前者比后者大，则进行交换。每一轮排序结束，选出一个未排序中最大的数放到数组后面。
2、快速排序
基本思想:选取一个基准元素，通常为数组最后一个元素（或者第一个元素）。从前向后遍历数组，当遇到小于基准元素的元素时，把它和左边第一个大于基准元素的元素进行交换。在利用分治策略从已经分好的两组中分别进行以上步骤，直到排序完成。
3、直接插入排序
基本思想：和交换排序不同的是它不用进行交换操作，而是用一个临时变量存储当前值。当前面的元素比后面大时，先把后面的元素存入临时变量，前面元素的值放到后面元素位置，再到最后把其值插入到合适的数组位置。
4、直接选择排序
基本思想：依次选出数组最小的数放到数组的前面。首先从数组的第二个元素开始往后遍历，找出最小的数放到第一个位置。再从剩下数组中找出最小的数放到第二个位置。以此类推，直到数组有序。
以上内容参考 网络-排序算法、网络-c语言冒泡排序
⑸ 谁能提供C语言里起泡法排序和快速排序法的流程图谢谢！！ 重赏！！
冒泡排序: (数字都是序号 1~9 为 第一到第九个数字 假如 一共9个数字比较)
1 和 2 比较 小于就交换位置 然后
1 和 3 比较 小于就交换位置 然后
1 和 4 比较 小于就交换位置 然后
......
1 和 9 比较 小于就交换位置 然后
2 和 3 比较 小于就交换位置 然后
2 和 4 比较 小于就交换位置 然后
......
2 和 9 比较 小于就交换位置 然后
3 和 4 比较 小于就交换位置 然后
3 和 5 比较 小于就交换位置 然后
....
...
8 和 9 比较 小于就交换位置 全部结束 所得序列从小到大排列
快速排列:
第一个数 跟 整个序列中间一个数比较 要是小于 就在跟前半段中间个数比较 要是又大于 就跟前半段中的后半段中间个数比较 来确定位置
如:
1 跟 (1+9)/2 比较 小于就继续跟 (1+5)/2比较 大于就跟(5+9)/2比较
然后(假设是小于) 1跟(1+5)/2比较 又大于 那么继续1跟(3+5)/2比较 要是
1大于4那么交换位置
然后第二段: 2 跟 (1+9)/2比较 小于就继续跟 (1+5)/2比较 大于就跟(5+9)/2比较
以此类推...
9跟(1+5)/2 比较........
⑹ C语言冒泡排序法是怎么排序的
C语言冒泡排序法的排序规则：
将被排序的记录数组R[1..n]垂直排列，每个记录R看作是重量为R.key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。
初始 R[1..n]为无序区。
第一趟扫描 从无序区底部向上依次比较相邻的两个气泡的重量，若发现轻者在下、重者在上，则交换二者的位置。
即依次比较(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]上。
第二趟扫描 扫描R[2..n]。
扫描完毕时，"次轻"的气泡飘浮到R[2]的位置上…… 最后，经过n-1 趟扫描可得到有序区R[1..n] 注意： 第i趟扫描时，R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时，该区中最轻气泡飘浮到顶部位置R上，结果是R[1..i]变为新的有序区。
⑺ C语言冒泡排序。
#include<stdio.h>
void main()
{
int a[10];
int i,j,t;
printf("input 10 numbers: ");
for(i=0;i<10;i++)
scanf("%d",&a[i]);
for(j=0;j<9;j++) /*进行9次循环 实现9趟比较*/
for(i=0;i<9-j;i++) /*在每一趟中进行9-j次比较*/
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: ");
for(i=0;i<10;i++)
printf(" %d",a[i]);
}
(7)c语言冒泡排序流程图扩展阅读：
冒泡排序算法的运作
1、比较相邻的元素。如果第一个比第二个大（小），就交换他们两个。
2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大（小）的数。
3、针对所有的元素重复以上的步骤，除了最后已经选出的元素（有序）。
4、持续每次对越来越少的元素（无序元素）重复上面的步骤，直到没有任何一对数字需要比较，则序列最终有序。
简单的表示
#include <stdio.h>
void swap(int *i, int *j)
{
int temp = *i;
*i = *j;
*j = temp;
}
int main()
{
int a[10] = {2,1,4,5,6,9,7,8,7,7};
int i,j;
for (i = 0; i < 10; i++)
{
for (j = 9; j > i; j--)//从后往前冒泡
{
if (a[j] < a[j-1])
{
swap(&a[j], &a[j-1]);
}
}
}
for (i = 0; i < 10; i++)
{
printf("%d ", a[i]);
}
return 0;
}