黑马程序员技术交流社区

标题: 用冒泡法对10个数排序 [打印本页]
作者: a1130003724    时间: 2014-5-17 12:47
标题: 用冒泡法对10个数排序
本帖最后由 a1130003724 于 2014-5-21 14:20 编辑

看了书上的冒泡法对10个数的排序，没怎么看懂求各位大神详细讲解下  小弟在这里先谢谢各位了
作者: 一只小菜鸟    时间: 2014-5-17 12:57
  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. }

  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. }

  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. }
复制代码
作者: 傘が咲く    时间: 2014-5-17 13:08

冒泡排序：

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



  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. }
复制代码




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

谢谢   讲解的很详细   中间不大懂的地方也注释了
作者: a1130003724    时间: 2014-5-17 13:17
一只小菜鸟 发表于 2014-5-17 12:57

中间一些关键语句有解释就好了   
作者: 傘が咲く    时间: 2014-5-17 13:34
a1130003724 发表于 2014-5-17 13:16
谢谢   讲解的很详细   中间不大懂的地方也注释了

:handshake
作者: 1014917278    时间: 2014-5-17 14:43
大数往后放～～～
作者: forever决    时间: 2014-5-17 19:55
中心思想就是大数往下沉，小数向上升，具体算法就是拿第一个数与剩下的九个数依次比较，如果比较大，就交换数值，如果比较后一个数小就换到第二个数与剩下的八个数依次比较。希望对你有些帮助
作者: Sniper_YJ    时间: 2014-5-17 23:35
受教了。。。。
作者: 吉大人    时间: 2014-5-18 09:56
这个在数据结构一书中有记载
作者: 白羊爱芒果    时间: 2014-5-18 11:33
终于体会到为啥有数据结构这门课了
作者: 诺忔。初禾、    时间: 2014-5-18 12:28
你应该把你哪个地方没理解的说下
作者: 子城伯涵    时间: 2014-5-20 20:28
#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;
        
}




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2