看了书上的冒泡法对10个数的排序，没怎么看懂求各位大神详细讲解下  小弟在这里先谢谢各位了

1. //插入排序：每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；直到待排序数据元素全部插入完为止。
   
2. void insertSort(int a[],int len){
   
3.     int temp;
   
4.     for (int i=1; i<len; i++) {
   
5.         for (int j=0; j<i; j++) {
   
6.             if (a[j]>a[i]) {
   
7.                 temp=a[i];
   
8.                 a[i]=a[j];
   
9.                 a[j]=temp;
   
10.             }
    
11.         }
    
12.     }
    
13.     for (int i=0; i<len; i++) {
    
14.         printf("%d ",a[i]);
    
15.     }
    
16. }
    
17. 
    
18. int main(){
    
19.     int a[]={3,4,1,11,5,2,6,566,22,43};
    
20.     int len=sizeof(a)/sizeof(int);
    
21.     ascSort(a,len);
    
22.     return 0;
    
23. }
    
24. 
    
25. 二、选择排序：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
    
26. void selectSort(int a[],int len){
    
27.     int temp;
    
28.     for (int i=0; i<len-1; i++) {
    
29.         for (int j=i+1; j<len; j++) {
    
30.             if (a[i]>a[j]){
    
31.                 temp=a[i];
    
32.                 a[i]=a[j];
    
33.                 a[j]=temp;
    
34.             }
    
35.         }
    
36.     }
    
37.     for (int i=0; i<len; i++) {
    
38.         printf("%d ",a[i]);
    
39.     }
    
40. }
    
41. //三、冒泡排序:两两比较待排序数据元素的大小，发现两个数据元素的次序相反时即进行交换，直到没有反序的数据元素为止。
    
42. void bubbleSort(int a[],int len){
    
43.     int temp;
    
44.     for (int i=0; i<len; i++) {
    
45.         for (int j=0; j<len-1-i; j++) {
    
46.             if (a[j]>a[j+1]) {
    
47.                 temp=a[j];
    
48.                 a[j]=a[j+1];
    
49.                 a[j+1]=temp;
    
50.             }
    
51.         }
    
52.     }
    
53.     for (int i=0; i<len; i++) {
    
54.         printf("%d ",a[i]);
    
55.     }
    
56. }
    

复制代码

冒泡排序：

　　冒泡排序是一种容易理解的，经典的排序。其原理是利用两重循环，每次内循环比较相邻的元素，将大的元素 (升序，反之则为降序) 向后交换；每次外循环挑出一个极值，并放在数组的末尾。核心的代码如下：

1. 
   
2. void bubbleSort(int array[],int length)
   
3. {
   
4.     int i,j,temp;
   
5.     for(i = 0;i<length;i++)
   
6.         for(j=0;j<length-i-1;j++)  // length是数组长度，-1目的是防止当i取0时候，j+1引起数组下标越界。
   
7.             if(array[j]>array[j+1])
   
8.             {
   
9.                                 // 前面的元素大于后面的元素，则交换两元素的值，每次内循环将最大的数放到最后
   
10.                 temp = array[j];
    
11.                 array[j] = array[j+1];
    
12.                 array[j+1] = temp;
    
13.             }
    
14. }

复制代码

傘が咲く 发表于 2014-5-17 13:08
冒泡排序：　　冒泡排序是一种容易理解的，经典的排序。其原理是利用两重循环，每次内循环比较相邻的元素 ...

谢谢   讲解的很详细   中间不大懂的地方也注释了

一只小菜鸟 发表于 2014-5-17 12:57

中间一些关键语句有解释就好了   

a1130003724 发表于 2014-5-17 13:16
谢谢   讲解的很详细   中间不大懂的地方也注释了

:handshake

大数往后放～～～

中心思想就是大数往下沉，小数向上升，具体算法就是拿第一个数与剩下的九个数依次比较，如果比较大，就交换数值，如果比较后一个数小就换到第二个数与剩下的八个数依次比较。希望对你有些帮助

受教了。。。。

这个在数据结构一书中有记载

终于体会到为啥有数据结构这门课了

你应该把你哪个地方没理解的说下

#include<stdio.h>
#include<string.h>
int main()
{
        int ai[10]={1,3,4,5,66,7,2,11,44,22};
        size_t i=10;
        int x;
        int tem;
        while(i>1)
        {
                x=1;
                for(int j=1;j<i;++j)
                {
                        if( ai[j]> ai[j+1])
                        {
                                tem=ai[j];
                                ai[j]=ai[j+1];
                                ai[j+1]=tem;
                                x=j;
                        }
               
                }
                i=x;
        }
         printf("排序后的数为：\n");
        for(int ix=0;ix!=10;++ix)
        {
                printf("%d\n",ai[ix]);
        }
        return 0;
        
}