冒泡排序：定义大小为100的整形数组，使用随机函数给数组元素赋值。数值范围1-100，并且排序，使用冒泡排序实现。

定义大小为100的整形数组，使用随机函数给数组元素赋值。数值范围1-100，并且排序，使用冒泡排序实现。随机函数链接地址：

rand - C++ Reference (cplusplus.com)

源代码：

#include
#include
#define ARSIZE 100
void swap(int*a,int*b)
{
    int tmp=*a;
    *a=*b;
    *b=tmp;
}
int main()
{
    int ar[ARSIZE]={0};
    int val=0;
    for(int i=0;iar[j+1])
        {
            swap(&ar[j],&ar[j+1]);
            tag=false;
        }
        if(tag)
        {
            break;//如果此次循环没有发生交换，则退出
        }
    }
    
    for(int i=0;i

运行结果：

  42  68  35   1  70  25  79  59  63  65
   6  46  82  28  62  92  96  43  28  37
  92   5   3  54  93  83  22  17  19  96
  48  27  72  39  70  13  68 100  36  95
   4  12  23  34  74  65  42  12  54  69
  48  45  63  58  38  60  24  42  30  79
  17  36  91  43  89   7  41  43  65  49
  47   6  91  30  71  51   7   2  94  49
  30  24  85  55  57  41  67  77  32   9
  45  40  27  24  38  39  19  83  30  42

   1   2   3   4   5   6   6   7   7   9
  12  12  13  17  17  19  19  22  23  24
  24  24  25  27  27  28  28  30  30  30
  30  32  34  35  36  36  37  38  38  39
  39  40  41  41  42  42  42  42  43  43
  43  45  45  46  47  48  48  49  49  51
  54  54  55  57  58  59  60  62  63  63
  65  65  65  67  68  68  69  70  70  71
  72  74  77  79  79  82  83  83  85  89
  91  91  92  92  93  94  95  96  96 100

改进后的程序：

#include
#include
#define ARSIZE 100
void swap(int*a,int*b)
{
    int tmp=*a;
    *a=*b;
    *b=tmp;
}
void Init_Ar(int *a)
{
    int val=0;
    for(int i=0;ia[j+1])
        {
            swap(&a[j],&a[j+1]);
            tag=false;
        }
        if(tag)
        {
            break;//如果此次循环没有发生交换，则退出
        }
    }
    Print_Ar(a);
}
int main()
{
    int ar[ARSIZE]={0};
    Init_Ar(ar);//初始化数组
    Print_Ar(ar);//打印
    BubbleSort(ar);//冒泡排序
}

第二次改进，产生的随机数不重复

#include
#include
#define ARSIZE 100

void swap(int*a,int*b)
{
    int tmp=*a;
    *a=*b;
    *b=tmp;
}

int Findvalue(int a[],int k,int val)
{
    int pos=-1;
    for(int i=0;i 
运行结果：
 
  42  68  35   1  70  25  79  59  63  65
   6  46  82  28  62  92  96  43  37   5
   3  54  93  83  22  17  19  48  27  72
  39  13 100  36  95   4  12  23  34  74
  69  45  58  38  60  24  30  91  89   7
  41  49  47  71  51   2  94  85  55  57
  67  77  32   9  40  16  31  78  87  73
  98  56  75  53   8  88  84  10  14  11
  21  97  29  18  15  52  50  20  99  90
  86  44  81  80  76  33  26  61  64  66

   1   2   3   4   5   6   7   8   9  10
  11  12  13  14  15  16  17  18  19  20
  21  22  23  24  25  26  27  28  29  30
  31  32  33  34  35  36  37  38  39  40
  41  42  43  44  45  46  47  48  49  50
  51  52  53  54  55  56  57  58  59  60
  61  62  63  64  65  66  67  68  69  70
  71  72  73  74  75  76  77  78  79  80
  81  82  83  84  85  86  87  88  89  90
  91  92  93  94  95  96  97  98  99 100
 
第三次改进：查表法
 
#include
#include
#define ARSIZE 100

void swap(int*a,int*b)
{
    int tmp=*a;
    *a=*b;
    *b=tmp;
}

int Findvalue(int a[],int k,int val)
{
    int pos=-1;
    for(int i=0;i 
运行结果：
 
  42  68  35   1  70  25  79  59  63  65
   6  46  82  28  62  92  96  43  37   5
   3  54  93  83  22  17  19  48  27  72
  39  13 100  36  95   4  12  23  34  74
  69  45  58  38  60  24  30  91  89   7
  41  49  47  71  51   2  94  85  55  57
  67  77  32   9  40  16  31  78  87  73
  98  56  75  53   8  88  84  10  14  11
  21  97  29  18  15  52  50  20  99  90
  86  44  81  80  76  33  26  61  64  66

   1   2   3   4   5   6   7   8   9  10
  11  12  13  14  15  16  17  18  19  20
  21  22  23  24  25  26  27  28  29  30
  31  32  33  34  35  36  37  38  39  40
  41  42  43  44  45  46  47  48  49  50
  51  52  53  54  55  56  57  58  59  60
  61  62  63  64  65  66  67  68  69  70
  71  72  73  74  75  76  77  78  79  80
  81  82  83  84  85  86  87  88  89  90
  91  92  93  94  95  96  97  98  99 100