用冒泡法、简单插入和简单选择三种方式实现排序，每种排序过程中需要打印出循环执行的次数。

算法设计, 用代码完成三种简单的排序方法(冒泡,简单插入,简单选择)中的任何一个即可？~

排序算法是最基础的算法，冒泡算法如下：
void buble_sort(int arr[], int length)
{
int i, j, max;
for(i=0, i<length-1, i++)
{
for(j=0, j<length-i-1, j++)

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

{

max = a[j];

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

a[j+1] = max;

}

}

}
}

　　一、冒泡排序
　　已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与 a[2]的值，若a[1]大于a[2]则交换 两者的值，否则不变。再比较a[2]与a[3]的值，若a[2]大于a[3]则交换两者的值，否则不变。再比 较a[3]与a[4]，以此 类推，最后比较a[n-1]与a[n]的值。这样处理一轮后，a[n]的值一定是这组数据中最大的。再对a[1]~a[n- 1]以相同方法 处理一轮，则a[n-1]的值一定是a[1]~a[n-1]中最大的。再对a[1]~a[n-2]以相同方法处理一轮，以此类推。共处理 n-1 轮 后a[1]、a[2]、……a[n]就以升序排列了。
　　优点：稳定；
　　缺点：慢，每次只能移动相邻两个数据。

　　二、选择排序
　　每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数 据元素排完。
　　选择排序是不稳定的排序方法。
　　n 个记录的文件的直接选择排序可经过n-1 趟直接选择排序得到有序结果：
　　①初始状态：无序区为R[1..n]，有序区为空。
　　②第1 趟排序 在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1 个记录R[1]交换，使R[1..1]和R[2..n]分别变 为记录个数增加1 个的新有序区和记录个数减少1 个的新无序区。
　　③第i 趟排序
　　第i 趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(1≤i≤n-1)。该趟 排序从当前无序区中选出关键字最 小的记录 R[k]，将它与无序区的第1 个记录R 交换，使R[1..i]和R 分别变为记录个数增加1 个的新有序区和记录个数减少 1 个的新无序区。
　　这样，n 个记录的文件的直接选择排序可经过n-1 趟直接选择排序得到有序结果。
　　优点：移动数据的次数已知（n-1 次）；
　　缺点：比较次数多。

　　三、插入排序
　　已知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、 b[2]、……b[m]，需将二者合并成一个升序数列。 首先比较b[1]与a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值， 若b[1]仍然大于a[2]，则继续跳过，直 到b[1]小于a 数组中某一数据a[x]，则将a[x]~a[n]分别向后移动一位，将b[1]插入到原来 a[x]的位置这就完成了b[1] 的插入。b[2]~b[m]用相同方法插入。（若无数组a，可将b[1]当作n=1 的数组a）
　　优点：稳定，快；
　　缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决 这个问题。

　　四、缩小增量排序
　　由希尔在1959 年提出，又称希尔排序(shell 排序)。
　　已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。发现当n 不大时，插入 排序的效果很好。首先取一增 量d(d<n)，将a[1]、a[1+d]、a[1+2d]……列为第一组，a[2]、a[2+d]、 a[2+2d]……列为第二组……，a[d]、a[2d]、a[3d]……="" 列为最后一组以次类推，在各组内用插入排序，然后取d'<d，重复上述操="" 作，直到d="1。"
　　优点：快，数据移动少；=""
　　缺点：不稳定，d="" 的取值是多少，应取多少个不同的值，都无法确切知道，只能凭经验来取。=""

　　五、快速排序=""
　　快速排序是冒泡排序的改进版，是目前已知的最快的排序方法。
　　="" 已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先任取数据a[x]="" 作为基准。比较a[x]与其它数据并="" 排序，使a[x]排在数据的第k="" 位，并且使a[1]~a[k-1]中的每一个数="" 据a[x]，然后采 用分治的策略分别对a[1]~a[k-1]和a[k+1]~a[n] 两组数据进行快速排序。
　　优点：极快，数据移动少；
　　缺点：不稳定。

你分数太低，我把以前写的给你，自己修改选择排序：#include"stdio.h"
int main()
{
int array[6]={24,70,12,85,106,8};
int i,j,n=0,middle,sub,min;
for(j=0;j<6;j++)
{
min=array[n];
for(i=n;i<6;i++)
{
if(min>array[i])
{
min=array[i];
sub=i;
}
}
middle=array[n];
array[n]=array[sub];
array[sub]=middle;
n++;
}
for(j=0;j<6;j++)
printf("%d ",array[j]);
printf("\n");
return 0;
}

直接插入排序，不过是动态链表的
#define null 0
#include"stdio.h"
#include"malloc.h"
struct student
{
int num;
struct student *next;
};
int n=0;

struct student *create(void)
{
struct student *head,*p1,*p2;
p1=p2=(struct student*)malloc(sizeof(struct student));
head=null;
scanf("%d",&p1->num);
while(p1->num!=null)
{
n=n+1;
if(n==1)head=p1;
p1=(struct student*)malloc(sizeof(struct student));
p2->next=p1;
p2=p1;
scanf("%d",&p1->num);
}
p1->next=null;
return(head);
}
/*------------------
动态链表的建立
-------------------*/

struct student *paixu(struct student *head)
{
struct student *listp,*limbo,*listx;
/*----------------------------------------------------------------------------------------------------------
1.listP为无序区链表的遍历指针，作提取节点和有序区比较的作。
2.limbo为过渡指针，每当无序区遍历到的节点值小于有序区节点遍历到的值，则节点插到有序区链表的最后面，并且把
此节点的next地址设定为null，next为null为有序区链表遍历结束的条件，为了不使无序区的节点失去联系，需要把此
节点next的值赋值给limbo,再把null赋值给next，把limbo的值赋值给listp，使listP指向无序区下一个需要插入节点。
3.listx为有序区链表的便利指针，listx->next=null为遍历结束的标示。
------------------------------------------------------------------------------------------------------------*/
listp=limbo=listx=head;
if(listp->num!=null)
{
listp=listp->next;
head->next=null;
}
else printf("链表为空，无法排序");
/*-----------------------------------------------------------------------------------------
把第一个节点放入有序区，listp指向下一个需要比较的节点，然后把刚放入有序的阶段的next设为null。
-------------------------------------------------------------------------------------------*/
if(listp->num!=null)
{
if(listp->num>head->num)
{
limbo=listp->next;
listp->next=head;
head=listp;
listp=limbo;
}
else
{
head->next=listp;
limbo=listp->next;
listp->next=null;
listp=limbo;
}
}
/*------------------------------------------------------------------------------------------------
第二个节点放入有序区，如果大于有序区的首节点，就让有序区的头指针指向它，指针listP指向下一个需要
比较的节点；否则就把节点的next设置为null，在让指针p指向下一个需要比较的节点（利用过渡节点limbo）。
-------------------------------------------------------------------------------------------------*/
while(listp->num!=null)
{
listx=head;
while(listx->next!=null)
{
if(listp->num>listx->num)
{
limbo=listp->next;
listp->next=head;
head=listp;
listp=limbo;
break;
}
if(listp->num>=listx->next->num&&listp->num<=listx->num)
{
limbo=listp->next;
listp->next=listx->next;
listx->next=listp;
listp=limbo;
break;
}
else
{
listx=listx->next;
}
}
if(listx->next==null&&listp->num<listx->num)
{
listx->next=listp;
limbo=listp->next;
listp->next=null;
listp=limbo;
}
}
/*--------------------------------------------------------------------------------------------------------------------------------
把其余节点依次放入有序区，
如果大于有序区的首节点，就让有序区的头指针指向它，指针listP指向下一个需要比较的节点；
如果小于有序区的当前尾节点，插入在有序区链表尾部，把节点的next设置为null，让指针listp指向下一个需要比较的节点（用过渡节点limbo）；
如果小于等于当前listx指向的节点并且大于等于listx->next指向的节点，就插入他们中间。
---------------------------------------------------------------------------------------------------------------------------------*/
return(head);
/*-------------------------
把head的值返回给函数。
--------------------------*/
}
int print(struct student *head)
{
struct student *y;
y=head;
while(y)
{
printf("%d ",y->num);
y=y->next;
}
return 0;
}
/*--------------
链表输出
---------------*/

int main(void)
{
struct student *head,*a;
head=create();
a=paixu(head);
print(a);
return 0;
}

冒泡排序么有，因为是诸多排序中算法最简单的，懒得写，你可以去华夏联盟问问，里面很多高中帮助你

自己的作业题还好意思拿出来.

---

怒江傈僳族自治州17890912023： C++题:编制数组排序,用冒泡排序、选择排序、插入排序三种方法. 急需答案!! - ？
子车昌小儿： 分太少了,还是给你写一个吧#include <stdio.h> #include <time.h> #include <stdlib.h>#define N 10void BubbleSort(int a[]) {int i,j,t;for (i=0;i<N;i++){for (j=i+1;j<N;j++){if(a[i]>a[j]){t=a[i];a[i]=a[j];a[j]=t;}}} }void SelectSort(int a[]) {int i,j,t,...

怒江傈僳族自治州17890912023： 一道vf题.,,..求帮忙 用多重循环做随机产生10个数,用冒泡,选择,插入三种方法按从小到大排列 - ？
子车昌小儿： 只写算法了,写全程序太多了 冒泡排序 a[1]~a[10]:10个随机数 for i = 1 to 10 do for j= i to 10 do if a[j]>a[i] then x= a[j] a[j]=a[i] a[i]=x end 选择排序 a[1]~a[10]:10个随机数 b[1]~b[10]:空数列 for i= 10 downto 1 do {x=1 for j= 1 to i do [ if a[j]>a[x] then x=j...

怒江傈僳族自治州17890912023： 在直接插入排序、冒泡排序、简单选择排序和快速排序方法中,能在第一趟排序中就得到最大元素的排序方法是 - ？
子车昌小儿：[答案] 冒泡排序,如果是升序的,它第一次先找出最大的元素,第二次找第二大的元素,直到到最后一个! 希望我的回答对你有用!

怒江傈僳族自治州17890912023： 编写程序,实现三种排序算法(选择、插入、冒泡) - ？
子车昌小儿： 选择排序如下:#include <stdio.h>#include <stdlib.h> void choose_sort( int array[], int s, int e ); int main( void ) { int array[100]; int num; int i; int j; int k; printf( ＂input the amout(<100) of the array:＂ ); scanf( ＂%d＂, &num ); for( i = 0; i < num; i++) { ...

怒江傈僳族自治州17890912023： 数组的三种排序(冒泡,选择,插入)封装成三个静态方法,怎么去做 ？
子车昌小儿： 这个要看你用什么语言了,若是JAVA的,在类中定义static void Insert_Sort(int []a) { //你的插入排序程序 };static void Select_Sort(int []a) { //你的选择排序程序} ;static void Bubble_Sort(int []a) {// 你的冒泡排序程序 };就可以了

怒江傈僳族自治州17890912023： 二级C语言排序技术2 - ？
子车昌小儿： (1)交换类排序法交换类排序法是指借助数据元素之间的互相交换进行排序的一种方法.冒泡排序法与快速排序法都属于交换类排序方法.冒泡排序法是一种最简单的交换类排序方法,它是通过相邻数据元素的交换逐步将线性表变成有序.假设线...

怒江傈僳族自治州17890912023： 关于简单选择排序、直接插入排序和冒泡排序？
子车昌小儿： 帮你修改好了. 你的程序错误太多了. 你之前学过更高级的语言吧?居然这样用:R[i].key>R[j].key #include #include #include #define datatype int void SelectSort(datatype R[],int n) { int i,k,j; for(i=1;iR[j+1].key) if(R[j]>R[j+1]) { R[0]=R[j]; R[j]=R[j+1]; ...

怒江傈僳族自治州17890912023： C语言题目11.写三个函数排序函数,分别采用冒泡法、选择法、插入 ？
子车昌小儿： #define swap(a,b){int t=a;a=b;b=t;} #define compswap(a,b){if(b=i;i--) { compswap(a[j-left],a[j]); } } int mini(int a[],int i,int r) { int j,min=i; for(j=i+1;jleft&&(v

怒江傈僳族自治州17890912023： C语言排序(冒泡,快速排序和简单选择法排序)问题 - ？
子车昌小儿： 冒泡:很常见,就不细说原理了#include<stdio.h> void main() {int a[10] = {10,9,8,7,6,5,4,3,2,1}; int i =0 ; int j = 0;for(i = 0;i < 10;i++)for(j = i+1;j < 10;j++)if(a[i] > a[j]) { int t = a[i]; a[i]=a[j]; a[j]=t;} for(i =0 ;i< 10;i++){ printf(＂%d ＂,a[i]); } printf(＂\n＂...

怒江傈僳族自治州17890912023： c#:排序算法的实现.分别利用冒泡、直接插入、直接选择算法实现排序(升序). - ？
子车昌小儿： //冒泡排序 public static void Sort(int[] array) { int[] arr=new int[]{45,12,44,4,5}; for(int j=1;j<arr.Length;j++) {//外循环每次把参与排序的最大数排在最后 for(int i=0;i<arr.Length-j;i++) { //内层循环负责对比相邻的两个数,并把最大的排在后面 if(arr[i]>arr[...