请问什么是冒泡排序法，可以给出例子讲解下吗？

#include <stdio.h>  
  
void swap(int *a, int *b); //交换两个数  
  
int main()  
{  
    int     str[10];  
    int     i, j;  
    //初始化数组为10 9 8 7 6 5 4 3 2 1  
    for (i = 0; i < 10; i++)  
    {  
        str[i] = 10 - i;  
    }  
    //排序，从a[0]开始排，从小到大  
    for (i = 0; i < 10; i++)  
    {  
        for (j = i + 1; j < 10; j++)  
        {  
            if (str[i] > str[j])  
            {  
                swap(&str[i], &str[j]);  
            }  
        }  
    }  
        //将十个数输出  
    for (i = 0; i < 10; i++)  
        printf("%d\n", str[i]);  
    return    0;  
}  
void swap(int *a, int *b)  
{  
    int     c;  
     c = *a;  
    *a = *b;  
    *b =  c;  
} 

网上找的代码，具体思想就是依次比较相邻两个数值，将最大的数值像泡泡一样冒到最前面。
例子 1 7 6 9
第一次交换：1 7 6 9
第二次交换：7 1 6 9
第三次交换：7 6 1 9
第四次交换：7 6 9 1
第五次交换：7 6 9 1
第六次交换：7 9 6 1
第七次交换：7 9 6 1
第八次交换：9 7 6 1

[此贴子已经被作者于2018-5-14 22:55编辑过]

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名“冒泡排序”。
冒泡排序算法的运作如下：（从后往前）
1:比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2:对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3:针对所有的元素重复以上的步骤，除了最后一个。
4:持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较.
算法分析编辑
时间复杂度
若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数 C 和记录移动次数 M 均达到最小值：C=n-1  ，m=0  。

#include <stdio.h>

 void sort(int *a,int len)

 {
   int i=0;
   int j;
   int t;
   for(i=0;i<len-1;i++)  
     {
       for(j=0;j<len-i-1;j++)
          {
           if(a[j]>a[j+1])
              {
                t=a[j];
                a[j]=a[j+1];
                a[j+1]=t;
             }
          }
    }
  }
int main(int argc, char *argv[])
{
   int a[10]={-999,2,3,77,12,88,0,-8,99,100};
   int i=0;
   sort(a,10);
   for(i=0;i<10;i++)
             printf("%d ",a[i]);
  return 0;
}

[此贴子已经被作者于2018-5-14 22:01编辑过]

  c语言排序法 包括冒泡法在内共计8种：
  1：冒泡排序
  2：快速排序
  3：插入排序
  4：希尔排序
  5：选择排序
  6：堆排序
  7：归并排序
  8：基数排序

/*--------------------冒泡排序---------------------*/
void bubleSort(int data[], int n) {
    int i,j,temp;
    //两个for循环，每次取出一个元素跟数组的其他元素比较
    //将最大的元素排到最后。
    for(j=0;j<n-1;j++) {
        //外循环一次，就排好一个数，并放在后面，
        //所以比较前面n-j-1个元素即可
        for(i=0;i<n-j-1;i++) {
            if(data[i]>data[i+1]) {
                temp = data[i];
                data[i] = data[i+1];
                data[i+1] = temp;
            }
        }
    }  
}

/*--------------------快速排序---------------------*/
int findPos(int data[], int low, int high) {
    //将大于t的元素赶到t的左边，大于t的元素赶到t的右边
    int t = data[low];
    while(low < high) {
        while(low < high && data[high] >= t) {
            high--;
        }
        data[low] = data[high];
        while(low < high && data[low] <=t) {
            low++;
        }
        data[high] = data[low];
    }
    data[low] = t;
    //返回此时t在数组中的位置
    return low;
}
//在数组中找一个元素，对大于该元素和小于该元素的两个数组进行再排序
//再对两个数组分为4个数组，再排序，直到最后每组只剩下一个元素为止
void quickSort(int data[], int low, int high) {
    if(low > high) {
        return;
    }
    int pos = findPos(data, low, high);
    quickSort(data, low, pos-1);
    quickSort(data, pos+1, high);
}

/*--------------------插入排序---------------------*/
void bInsertSort(int data[], int n) {
    int low,high,mid;
    int temp,i,j;
    for(i=1;i<n;i++) {
        low = 0;
        //把data[i]元素插入到它的前面data[0-(i-1)]中
        temp =data[i];
        high = i-1;
        //该while是折半，缩小data[i]的范围(优化手段)
        while(low <= high) {
            mid = (low+high)/2;
            if(data[mid] > temp) {
                high = mid-1;
            }
            else {
                low = mid+1;
            }
        }
        int j = i;
        //让data与已经排序好的数组的各个元素比较，小的放前面
        while((j > low) && data[j-1] > temp) {
            data[j] = data[j-1];
            --j;
        }
        data[low] = temp;
    }
}

/*--------------------希尔排序---------------------*/
void shellSort(int * data, int n) {
    int step,i,j,key;
    //将数组按照step分组，不断二分到每组只剩下一个元素
    for(step=n/2;step>0;step/=2) {
        //将每组中的元素排序，小的在前
        for(i=step;i<n;i++) {
            key = data[i];
            for(j=i-step;j>=0 && key<data[j];j-=step) {
                data[j+step] = data[j];
            }
            //和上面的for循环一起，将组中小的元素换到数组的前面
            data[j+step] = key;
        }
    }
}

/*--------------------选择排序---------------------*/
void selectSort(int data[], int n) {
    int i,j,mix,temp;
    //每次循环数组，找出最小的元素，放在前面，前面的即为排序好的
    for(i=0;i<n-1;i++) {
        //假设最小元素的下标
        int mix = i;
        //将上面假设的最小元素与数组比较，交换出最小的元素的下标
        for(j=i+1;j<n;j++) {
            if(data[j] < data[mix]) {
                mix = j;
            }
        }
        //若数组中真的有比假设的元素还小，就交换
        if(i != mix) {
            temp = data[i];
            data[i] = data[mix];
            data[mix] = temp;
        }
    }
}

/*--------------------堆排序---------------------*/
//堆排序将数组先组成二叉树，默认从数组的data[1]开始排，data[0]是
//无效数据
void heapSort(int data[], int n) {
    int i;
    //先将数组组成一棵完全二叉树
    //从2/n开始，就是从倒数第二排结点往前开始
    for(i=n/2;i>0;i--) {
        heapAdjust(data, i, n);
    }
    //循环每个结点，将大的结点交换到堆顶
    for(i=n;i>1;i--) {
        swap(data, 1, i);
        //每次交换完都要调整二叉树，将剩下的最大的结点交换到堆顶
        heapAdjust(data, 1, i-1);
    }
}
//交换函数
void swap(int data[], int i, int j) {
    int temp;
    temp = data[i];
    data[i] = data[j];
    data[j] = temp;
}
void heapAdjust(int data[], int i, int n) {
    int j, temp;
    //假设第一个结点的元素是最大的
    temp = data[i];
    //i结点：2*i是i结点的左结点，2*i+1是i结点的右结点
    //把结点元素大的交换到前面
    for(j=2*i;j<=n;j*=2) {
        if(j < n && data[j] < data[j+1]) {
            j++;
        }
        if(temp >= data[j]) {
            break;
        }
        data[i] = data[j];
        i = j;
    }
    data[i] = temp;
}

/*--------------------归并排序---------------------*/
void mergeSort(int data[], int first, int last) {
    int mid = 0;
    //将数组不停的二分分组再组合，直到每组只剩一个元素
    if(first < last) {
        mid = (first+last)/2;
        mergeSort(data, first, mid);
        mergeSort(data, mid+1, last);
        merge(data, first, mid, last);
    }
    return;
}
void merge(int data[], int low, int mid, int high) {
    int i, k;
    //定义一个临时数组存放传进来的无序数组排好序之后的数组
    int *temp = (int *)malloc((high-low+1)*sizeof(int));
    //将无序数组分成两个序列
    int left_low = low;
    int left_high = mid;
    int right_low = mid+1;
    int right_high = high;
    //将两个序列比较排序，小的排前
    for(k=0;left_low<=left_high && right_low<=right_high;k++) {
        if(data[left_low]<=data[right_low]) {
            temp[k] = data[left_low++];
        }
        else{
            temp[k] = data[right_low++];
        }
    }
    //左序列如果有剩下元素未排序，加到临时数组的末尾
    if(left_low <= left_high) {
        for(i=left_low;i<=left_high;i++) {
            temp[k++] = data[i];
        }
    }
    //右序列如果有剩下元素未排序，加到临时数组的末尾
    if(right_low <= right_high) {
        for(i=right_low;i<=right_high;i++) {
            temp[k++] = data[i];
        }
    }
    //将排好序的小分组转移到原数组中
    for(i=0;i<high-low+1;i++) {
        data[low+i] = temp[i];
    }
    free(temp);
    return;
}
/*--------------------基数排序---------------------*/
//该函数的作用是找出num的pos位数的数字(比如：23的个位数数字是3)
int getNumPos(int num, int pos) {
    int i;
    int temp = 1;
    for(i=0;i<pos-1;i++) {
        temp *= 10;
    }
    return (num / temp) % 10;
}
void radixSort(int data[], int n) {
    int i,j,k,pos,num,index;
    //这几句话是创建一个从0-9(行)× (n+1)(列)的网格，第一列从上往下是0-9,
    //第二列是该行包含的元素个数，默认为0个
    int *radixArrays[10];
    for(i=0;i<10;i++) {
        radixArrays[i] = (int *)malloc(sizeof(int) * (n+1));
        radixArrays[i][0] = 0;
    }
    //pos最大为31为数，计算机能承受的最大范围了
    for(pos=1;pos<=31;pos++) {
        //该for循环是将数组的元素按照位数(pos)的值放进网格内
        for(i=0;i<n;i++) {
            num = getNumPos(data[i], pos);
            index = ++radixArrays[num][0];
            radixArrays[num][index] = data[i];
        }
        //该for循环是将上面的for循环已经按照某个位数(pos)排列好的元素存入数组
        for(i=0,j=0;i<10;i++) {
            for(k=1;k<=radixArrays[i][0];k++) {
                data[j++] = radixArrays[i][k];
            }
            //清空网格，以便给下个位数排列
            radixArrays[i][0] = 0;
        }
    }
}

谢谢