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

已于 2022-06-05 20:28:15 修改
阅读量1.5k 收藏 12
点赞数
分类专栏： C语言学习 文章标签： 排序算法 算法 c语言 c++ 数据结构
于 2022-05-18 11:11:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42939980/article/details/124838370
版权

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

rand - C++ Reference (cplusplus.com)

源代码：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#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;i<ARSIZE;++i)
    {
        val=rand()%100 +1;
        ar[i]=val;

    }
    for(int i=0;i<ARSIZE;++i)
    {
        printf("%4d",ar[i]);
        if((i+1)%10==0)
        {
            printf("\n");
        }
    }
    printf("\n");
    //冒泡排序 从小到大
    assert(br!=nullptr);
    for(int i=0;i<ARSIZE;++i)
    {
        bool tag=true;
        for(int j=0;j<ARSIZE-i;++j)       
        if(ar[j]>ar[j+1])
        {
            swap(&ar[j],&ar[j+1]);
            tag=false;
        }
        if(tag)
        {
            break;//如果此次循环没有发生交换，则退出
        }
    }
    
    for(int i=0;i<ARSIZE;++i)
    {
        printf("%4d",ar[i]);
        if((i+1)%10==0)
        {
            printf("\n");
        }
    }
return 0;

}

运行结果：

  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<stdio.h>
#include<stdlib.h>
#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;i<ARSIZE;++i)
    {
        val=rand()%100 +1;
        a[i]=val;

    }
}
void Print_Ar(int *a)
{
    for(int i=0;i<ARSIZE;++i)
    {
        printf("%4d",a[i]);
        if((i+1)%10==0)
        {
            printf("\n");
        }
    }
    printf("\n");
}
void BubbleSort(int *a)
{
    //冒泡排序 从小到大

    for(int i=0;i<ARSIZE;++i)
    {
        bool tag=true;
        for(int j=0;j<ARSIZE-i;++j)       
        if(a[j]>a[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<stdio.h>
#include<stdlib.h>
#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<k;i++)
    {
        if(a[i]==val)
        {
            pos=i;
            break;//只要有相等就退出
        }
    }
    return pos;
}

void Init_Ar(int *a)
{
    int val=0;
    int i=0;
    while(i<ARSIZE)
    {
        val=rand()%100 +1;
        if(Findvalue(a,i,val)==-1)
        {
            a[i]=val;
            ++i;
        }
        //或者else{i--;}
    }
}
/*void Init_Ar(int *a)
{
    int val=0;
    for(int i=0;i<ARSIZE;++i)
    {
        while(1)
        {
        val=rand()%100 +1;
        if(Findvalue(a,i,val)==-1)
        {
            a[i]=val;
            break;
        }
        }//或者else{i--;}
    }
}
*/
void Print_Ar(int *a)
{
    for(int i=0;i<ARSIZE;++i)
    {
        printf("%4d",a[i]);
        if((i+1)%10==0)
        {
            printf("\n");
        }
    }
    printf("\n");
}

void BubbleSort(int *a)
{
    //冒泡排序 从小到大
    for(int i=0;i<ARSIZE;++i)
    {
        bool tag=true;
        for(int j=0;j<ARSIZE-i;++j)       
        if(a[j]>a[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);
}

运行结果：

  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<stdio.h>
#include<stdlib.h>
#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<k;i++)
    {
        if(a[i]==val)
        {
            pos=i;
            break;//只要有相等就退出
        }
    }
    return pos;
}

void Init_Ar(int *a,int *b)
{
    int val=0;
    int i=0;
    while(i<ARSIZE)
    {
        val=rand()%100 +1;
        if(b[val]==0)
        {
            a[i]=val;
            ++i;
            b[val]=1;
        }
        //或者else{i--;}
    }

}
/*void Init_Ar(int *a)
{
    int val=0;
    for(int i=0;i<ARSIZE;++i)
    {
        while(1)
        {
        val=rand()%100 +1;
        if(Findvalue(a,i,val)==-1)
        {
            a[i]=val;
            break;
        }
        }//或者else{i--;}
    }
}
*/
void Print_Ar(int *a)
{
    for(int i=0;i<ARSIZE;++i)
    {
        printf("%4d",a[i]);
        if((i+1)%10==0)
        {
            printf("\n");
        }
    }
    printf("\n");
}

void BubbleSort(int *a)
{
    //冒泡排序 从小到大
    for(int i=0;i<ARSIZE;++i)
    {
        bool tag=true;
        for(int j=0;j<ARSIZE-i;++j)       
        if(a[j]>a[j+1])
        {
            swap(&a[j],&a[j+1]);
            tag=false;
        }
        if(tag)
        {
            break;//如果此次循环没有发生交换，则退出
        }
    }
    Print_Ar(a);
}

int main()
{
    int ar[ARSIZE]={0};
    int br[ARSIZE+1]={0};
    Init_Ar(ar,br);
    Print_Ar(ar);
    BubbleSort(ar);
}

运行结果：

  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

胖胖熊℡
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
指针数组为字符串排序：1、冒泡排序 2、快速排序
07-11
指针数组为字符串排序，char* str[] = { "beijing","guangdong","shanghai" };进行排序，内涵冒泡排序和快速排序，原理：更改指针指向
队列基本概念和顺序式存储实现
m0_53157173的博客
03-03 560
队列的基本概念 队列的顺序存储
Java冒泡排序进行数组由小到大排序
qq_51560293的博客
11-02 2086
冒泡排序，由小到大
C语言实现冒泡排序
Tlzns的博客
12-22 1460
C语言实现冒泡排序思路及其代码
查找排序（顺序查找）一个表长100的顺序存储表，要求使用顺序查找列表中的元素并输出
u012220823的专栏
09-26 1791
//查找排序（顺序查找）一个表长100的顺序存储表，要求使用顺序查找列表中的元素并输出 #include #define SIZE 150    //100长度 typedef int Datatype; struct Seqlist {     Datatype data[SIZE];     int Length; }; v
定义大小为100的整型数组，使用随机函数给数组元素赋值，数值的范围为1-100,并且不容许重复
放纵小开爱的博客
01-15 3851
#include<stdio.h> #include<stdlib.h> #include<time.h> int main() { int a[100] = {0}, tmp = 0; for (int n = 0; n < 100; n++) { int tmp = rand() % 100 + 1; for (int i = 0; i <= n; i++) { if ( tmp !=a[i]) continue; else {
PHP 冒泡排序 二分查找 顺序查找 二维数组排序算法函数的详解
01-20
数据结构很重要，算法+数据结构+文档=程序使用PHP描述冒泡排序算法，对象可以是一个数组复制代码 代码如下://冒泡排序（数组排序）function bubble_sort($array) {$count = count($array);if ($count <= 0)return...
php数组冒泡排序算法实例
12-18
$i++){//需要比较$len-1轮，每一轮需要比较$len-1次 for($j=0;$j<$len-1;$j++){//需要比较$len-1次，因为循环到最后一个数时，后面没有数可以比较了，所以循环到倒数第二个数正好 $k=$j+1;//得到当前数的后一个...
二维数组如何进行冒泡排序
07-18
思路以及注意点、说明我都加在了代码旁边的注释里，好好悟悟！
js实现数组冒泡排序、快速排序原理
11-22
本文为大家分享了js数组冒泡排序、快速排序的实现原理，供大家参考，具体内容如下 1、冒泡排序： 　随便从数组中拿一位数和后一位比较，如果是想从小到大排序，那么就把小的那一位放到前面，大的放在后面，简单来说...
C语言练习3--遍历数组
LoveHoneyYou的博客
10-23 905
1).定义大小为100的整型数组, 使用随机函数给数组元素赋值。数值范围1..100, 并且排序，使用冒泡排随机函数 #include <stdlib.h> #include <stdio.h> #include <time.h> int main() { srand((unsigned int)time(NULL)); int arr[100] = { 0 }; int tmp = 0; int count = 0; for (int i = 0; i &
C语言实现顺序队列
qq_43629857的博客
06-24 8612
C语言详解顺序队列
c语言怎样给数组元素依次赋值,在第一组数组中给数组a的前10个元素依次赋值为1、2、3、···、10；在第2个循环中使数组变为1...
weixin_39985820的博客
05-24 3505
#include int main(){int i,a[10];for(i=0;i<10;i++)a[i]=i+1;for(i=0;i<5;i++)a[i+5]=a[i];for(i=0;i<10;i++)printf("%4d",a[i]);return 0;}扩展资料：使用规则1.可以只给部分元素赋初值。当{ }中值的个数少于元素个数时，只给前面部分元素赋值。例如：stati...
C语言学习(三) 数组
qq_37388518的博客
04-04 675
1. 一维数组 正如第一节中所说的那样，数组有三个特征点：数组名、数组元素数据类型、数组元素个数 数组是内存中一段连续存储的内存单元，在编译的时候才对其分配内存空间 1.1 一维数组的定义和初始化 int a[3] = { 1 , 2 , 3}; 类似于上面这条语句，一般都是这样定义的： 数据类型 数组名称 [ 数组元素数量 ] = { 初始化的值 }； 也可以不需要初始化，在后面的过程中进行初始化即可 1.2 一维数组的使用 使用一维数组的时候可以使用数组名加下标、指...
C++历险奇遇记
m0_62538383的博客
02-06 504
1.打印九九乘法表 #include<iostream> #include<time.h> //打印九九乘法表 using namespace std; int main(){ for (int i = 1; i <= 9; i++){ for (int j = 1; j <= i; j++){ cout << j << "*" << i << "=" << j*i << " .
冒泡排序，选择排序，插入排序，随机生成100个数并保存到数组中
叶卡捷琳堡的博客
01-17 4208
1.随机生成范围在1-100的数，并保存到数组中 #include<iostream> #include<ctime> using namespace std; int main() { //time()用系统时间初始化种。为rand()生成不同的随机种子。 srand((unsigned)time(NULL)); int* array = new int[10]; for (int index = 0; index < 10; index++) { //范围
(一)算法——冒泡排序、选择排序
热门推荐
至尊宝
09-04 2万+
强烈推荐一个大神的人工智能的教程：http://www.captainbed.net/zhanghan 简介 算法是解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。——摘自百度百科 为什么要用算法呢？假设现在给出三个数A,B,C，请你找出这三个数中最大的一个数。答案不止一种，不过我猜，有一部分人要选择if...el...
利用冒泡排序算法，将顺序表l中的元素从小到大进行排序。
最新发布
03-16
冒泡排序算法可以通过以下步骤将顺序表l中的元素从小到大进行排序： 1. 从第一个元素开始，依次比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们的位置。 2. 继续比较下一对相邻元素，直到最后一对元素。 3. 重复以上步骤，直到所有元素都排好序。 具体实现代码如下： ``` void bubbleSort(int l[], int n) { for (int i = ; i < n - 1; i++) { for (int j = ; j < n - i - 1; j++) { if (l[j] > l[j + 1]) { int temp = l[j]; l[j] = l[j + 1]; l[j + 1] = temp; } } } } ``` 其中，l为待排序的顺序表，n为顺序表中元素的个数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值