冒泡排序c语言 订阅
将被排序的记录数组R[1..n]垂直排列,每个记录R看作是重量为R.key的气泡。根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R:凡扫描到违反本原则的轻气泡,就使其向上"飘浮"。如此反复进行,直到最后任何两个气泡都是轻者在上,重者在下为止。 展开全文
将被排序的记录数组R[1..n]垂直排列,每个记录R看作是重量为R.key的气泡。根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R:凡扫描到违反本原则的轻气泡,就使其向上"飘浮"。如此反复进行,直到最后任何两个气泡都是轻者在上,重者在下为止。
信息
属    于
c语言
类    型
冒泡排序
中文名
c语言冒泡排序
属    性
计算机
c语言冒泡排序程序
冒泡排序
收起全文
精华内容
下载资源
问答
  • 2022-03-20 19:14:32

    考虑了数组本身有序的状况,提高了代码效率。 

    #include<stdio.h>
    //数组传参--冒泡排序法(考虑数组本身就是有序的情况,提高效率)
     void bubble_sort(int arr[], int sz) {
    	int i = 0;
    	for (i = 0;i < sz - 1;i++) {
          int flag = 1;
    		int j = 0;
    		for (int j = 0;j < sz - 1 - i;j++) {
    			if (arr[j] >arr[j + 1]) {
    				int tmp = arr[j];
    				arr[j] = arr[j + 1];
    				arr[j + 1] = tmp;
                  int flag=0;
    			}
    		}
          if(flag==1) break;
    	}
    }
    int main() {
    	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	bubble_sort(arr,sz);
    	for (int i = 0;i < sz;i++) {
    		printf("%d ", arr[i]);
    	}
    	return 0;
    }

    更多相关内容
  • 冒泡排序C语言

    2016-02-18 18:57:23
    冒泡排序C语言实现,很好用,提供给大家一起分享。
  • 044 冒泡排序 C语言
  • 链表插入排序和冒泡排序c语言

    千次阅读 2022-03-17 15:59:18
    链表排序问题 提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录链表排序问题前言一、pandas是什么?二、使用步骤1.引入库2.读入数据总结 前言 提示:这里可以添加本文要记录的大概...

    链表排序问题

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档


    前言

    链表与数组一样也有许多排序方式
    今天介绍链表的插入排序。


    冒泡排序

    1.思想

    在数组中冒泡排序之所以容易实现的原因在于: 数组中数据在内存中的存储是连续的,并且通过下标的改变就可以轻松改变指针所指的地址

    但在链表中,每个节点在内存中的位置是不确定的,所以不容易改变指针所指地址,来重复对链表内相邻节点的数据进行比较。

    2.代码

    数组

    void bubble(int a[],int len)
    {
    	int i,j,t;
    	for(i = 0; i < len; 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;
    			}
    		}                                                                     
    	}
    } 
    

    链表

    struct listnode* bubblesort(struct listnode *head)
    {
    	if(head == NULL)
    	return head; 
    	struct listnode *p,*q,*dummyhead;
    	int temp;
    	dummyhead = (struct listnode*)malloc(sizeof(struct listnode));
    	dummyhead->data = NULL;
    	dummyhead->next = head;
    	p = dummyhead;//p为冒牌中的交换趟数 
    	q = head;
    	while(p != NULL)
    	{
    		q = head;//每次q都应该重新回到最初点 
    		while(q->next != NULL)
    		{
    			if(q->data > q->next->data)//冒泡里的交换 
    			{
    				temp = q->data;
    				q->data = q->next->data;
    				q->next->data = temp;
    			}
    			q = q->next;
    		}
    		p = p->next;
    	}
    	return dummyhead->next;
    }
    

    插入排序

    1.思想

    插入排序的基本思想是,维护一个有序序列,初始时有序序列只有一个元素,每次将一个新的元素插入到有序序列中,将有序序列的长度增加 11,直到全部元素都加入到有序序列中

    如果是数组的插入排序,则数组的前面部分是有序序列,每次找到有序序列后面的第一个元素(待插入元素)的插入位置,将有序序列中的插入位置后面的元素都往后移动一位,然后将待插入元素置于插入位置。

    对于链表而言,插入元素时只要更新相邻节点的指针即可,不需要像数组一样将插入位置后面的元素往后移动。

    对于单向链表而言,只有指向后一个节点的指针,因此需要从链表的头节点开始往后遍历链表中的节点,寻找插入位置。

    2.代码

    数组插入排序

    代码如下(示例):

    void insert(int arr[],int len)
    {
    	int i,j,temp;
    	for(i = 1; i < len; i++)
    	{
    		temp = arr[i]; 
    		for(j = i - 1; j >= 0 && arr[j] > temp; j--)//找到比前一个大的值 
    		{
    			arr[j + 1] = arr[j];//将数组往后移一位 
    		}
    		arr[j + 1] = temp;//将temp储存的值赋予 
    	}
    }
    

    在这里插入图片描述


    链表代码

    struct listnode *insertsort(struct listnode *head)
    {
    	if(head == NULL) return head;//链表为空 
    	struct listnode* phead;//一个记录头结点的结点 
    	phead = (struct listnode*)malloc(sizeof(struct listnode));
    	phead->data = 0;
    	phead->next = head;
    	struct listnode *p,*q;
    	p = head;
    	q = p->next;
    	while(q != NULL)
    	{
    		if(p->data <= q->data)
    		{
    			p = p->next;
    		}
    		else
    		{
    			struct listnode* pre;
    			pre = phead;
    			while(pre->next->data <= q->data)//找到要插入位置的前一个结点 
    			{
    				pre = pre->next;
    			} 
    			p->next = q->next;
    			q->next = pre->next;
    			pre->next = q;//插入结点                                              
    		}
    		q = p->next;
    	}
    	return phead->next;
    	//return head;
    }
    

    总结

    学习了一下链表排序问题

    展开全文
  • 冒泡排序 C语言(从大到小排序)

    千次阅读 2022-02-05 14:58:46
    2 冒泡的概念 3 代码实现 1一维数组 一维数组 :存放字符型数据的数组 一维数组的定义 首先 arr[5] 5 是数组的长度 也就是大小 但是我们 在访问数组元素的地址 时候 不存在 有 arr[5] 也就是说 定义arr[5]...

    1 一维数组

    2 冒泡的概念

    3 代码实现

    1一维数组

    一维数组 :存放字符型数据的数组

    一维数组的定义

    首先 定义int arr[5](int类型的一维数组 ), 5 是数组的长度 也就是大小 但是我们 在访问数组元素的地址 时候, 不存在 有 arr[5]

    也就是说 定义arr[5]只是 为了 让你知道这个数组大小是 5 而已    我们在访问 数组的元素地址时候  是用下标来访问的 (从0开始 )  上述的两种定义的方法 都可以适用 在我们的元素长度和数组大小对不上时 他们自动补充 元素  我们有个这些概念之后  后面讲到的理解起来 都不会很吃力

    2 冒泡 的概念

     拿图中的五个数相比较   只要满足 前<后   我们就可以进行 交换  也就是 用下标法来比较   

    我们可以得出 我们拿五个数比较 第一轮 比较四次 得出 最大值  除去最大值 就是第二轮要比较的数   第二轮就是要比较 (比较的数量-1)就可以得本轮的最大值   其实第五轮 是没有比较的 因为只有一个数 (只是为了更直观 看到  全部 )

    3 代码实现 

    计算 数组大小的 关键字   sizeof  

    计算公式 

     int  len=sizeof(arr)/sizeof(arr[0]);

      函数声明

        void scan(int arr[],int len);
        void MaoPao(int arr[],int len);
        void print(int arr[],int len);
    

    函数声明 只是为了 养成 良好的 编程习惯  

     输入函数 

    //输入函数
        void scan(int arr[],int len)
        {
         for(int i=0;i<len;i++)
         {
         scanf("%d",arr+i);//输入五位数
         }

    因为 数组名就是 入口 地址  所以 我不用常规的方式 来写  输入函数    其实都一样的 

    冒泡排序 

         //冒泡 排序 函数
        void MaoPao(int arr[],int len)
        {
    
         int temp;
    
         for(int i=0;i<len-1;i++)
           {
    
         for(int j=0;j<len-i-1;j++)
         {
             if(arr[j]<arr[j+1])//满足条件 交换 到了下一次  并且 相应改变 位置
             {
                 temp=arr[j]; //开始交换 
                 arr[j]=arr[j+1];
                 arr[j+1]=temp;
    
    
             }
    
         }
    
           }
    
        }

     i 是轮次 我拿了 五个 数 可以发现 我只用了 四轮 就完成了 大小排序    

    j是 比较的次数  第一轮  用了 四次 (最开始有五个数 )所以 要 长度-1-i 

    如果 不减i的话 会导致  每一轮的比较次数都是一样的  这个要特别注意 

    输出 函数 

      
        void print(int arr[],int len)
        {
        printf("大小排序是:\n");
        for(int i=0;i<len;i++)
         {
          printf(" %d",*(arr+i));
    
         }
    
        }

    这里再说一次  输入 和输出 能用 arr+i 和 *(arr+i) 写的原因   常规写法 应该分别是 &arr[I] 和 arr[i]       我们这里要知道一个概念  数组名就是数组 的入口地址(首地址)

    主函数 的 调用 

    void main(void)//无参主函数 
        {
        int arr[5];
        int len;
        len=sizeof(arr)/sizeof(arr[0]);//计算数组大小
    
        scan(arr,len);//输入 
        MaoPao(arr,len);//排序
        print(arr,len);//输出 
    
        }
    

    最后结果

               冲冲冲冲冲冲 !!!!!!!!!!!!!!!!!!!!!!!!

                                                   最 后 感 谢 大 家 的 阅 读  

    展开全文
  • 冒泡排序C语言实现(源代码)

    千次阅读 2020-10-18 20:46:29
    冒泡排序 对一个元素个数为20个的随机数组进行冒泡排序 #include <stdio.h> #include <stdlib.h> #include <time.h> void swap(int &a, int &b){ int tmp = a; a = b; b = tmp; } ...

    冒泡排序

    对一个元素个数为20个的随机数组进行冒泡排序

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    void swap(int &a, int &b){
    	int tmp = a;
    	a = b;
    	b = tmp;
    }
    
    void Display(int *a, int n){
    	for (register int i = 0; i < n; i++){
    		printf("%d ", a[i]);
    	}
    	printf("\n");
    }
    
    void bubble_sort(int *a, int n){
    	register int i, j;
    	int flag;
    	//最多排序n-1次
    	for (i = 0; i < n - 1; i++){
    		flag = 0;
    		//每排序一次,都会有一个元素放在了正确的位置,所以j<n-i-1
    		for (j = 0; j < n - i - 1; j++){
    			if (a[j] > a[j + 1]){
    				swap(a[j], a[j + 1]);
    				flag = 1;
    			}
    		}
    		printf("第%d次冒泡排序后:", i + 1);
    		Display(a, n);
    		if (flag == 0) return;//如果一次交换都没有,则说明数组已经排好序,返回;
    	}
    }
    
    int main(){
    	int a[20];
    	//生成一个有20个元素的随机数组
    	srand((unsigned int)time(0));//修改种子
    	for (register int i = 0; i < 20; i++){	
    		a[i] = rand();
    	}
    	printf("原数组为:\n");
    	Display(a, 20);
    	printf("\n");
    	bubble_sort(a, 20);
    	printf("\n冒泡排序后:\n");
    	Display(a, 20);
    	return 0;
    }
    

    如有不足,欢迎各位大佬指正

    展开全文
  • 冒泡排序C语言(从小到大)

    千次阅读 2021-03-28 14:28:26
    冒泡排序C语言(从小到大) #include <stdio.h> void Maopao(int a[],int n){ int i,j,t; for( i=0;i<n-1;++i)//n个数,总共需要进行n-1次 { //n-1个数排完,第一个数一定已经归位 //每次会将最大(升序)或...
  • 冒泡排序C语言实现代码

    千次阅读 2020-09-14 22:55:15
    // 分类 -------------- 内部比较排序 // 数据结构 ---------- 数组 // 最差时间复杂度 ---- O(n^2) // 最优时间复杂度 ---- 如果能在内部循环第一次运行时,使用一个旗标来表示有无需要交换的可能,可以把最优时间...
  • 冒泡排序 c语言

    2019-03-28 15:32:13
    冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。 冒泡排序算法的原理如下: 比较相邻的元素。如果第一个比第二个大,就交换他们两个。 对每一对相邻元素做同样的工作,从开始第一对...
  • 冒泡排序C语言实现

    千次阅读 多人点赞 2016-10-20 18:51:28
    冒泡排序C语言实现
  • 冒泡排序C语言描述

    2021-05-28 22:15:50
    冒泡排序 之前发过C++描述的,现在再发一下·C语言描述的 冒泡排序.c #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<string.h> #include<stdlib.h> #include<time.h> #...
  • C语言冒泡排序C语言冒泡排序C语言冒泡排序
  • 实现了快速排序与冒泡排序C语言算法,并比较了二者的算法效率。 使用说明:#define中MAX值可更改,为数组中待排序元素的个数。数组元素采用随机数生成,本例为0~999的随机整数,可更改rand()%后的数字进行调整...
  • 冒泡排序c语言

    2012-09-10 14:48:09
    冒泡排序冒泡排序冒泡排序
  • c代码-冒泡排序(从小到大)
  • 冒泡排序C语言实现程序

    千次阅读 2019-11-23 23:47:44
    冒泡排序主要是要搞清楚两个for循环的边界条件,第一个for循环是代表需要进行多少趟排序,而第二个for循环是用来表示每一趟排序需要进行多少次比较,以元素数为6的数组为例,代码如下: #include<cstdio> ...
  • 冒泡排序 基本思想: 冒泡排序算法的运作如下: 1.比较相邻的元素。如果第一个比第二个大,就交换他们两个。 2.对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。...
  • C语言快速排序算法 用快速排序法对一组数据由小到大进行排序数据分别为 99451236692262 7964696 实现过程 (1)自定义一个函数 qusort)实现快速排序 (2) main) 函数为程序的入口函数程序代码如下 #include <stdio.h> ...
  • 冒泡排序 C语言

    2013-05-02 18:49:08
    冒泡排序 课后作业 经典的课后习题详解 你妹的长度还不够啊
  • #include<stdio.h> int main() { //输入三个数到数组中 int i, j, t; int a[3] = { 0 }; printf("请输入三个数:"); for (i = 0; i <... //冒泡排序 for (j = 0; j < 2; j++) { .
  • 冒泡排序C语言实现 - 源码详解

    千次阅读 2019-10-12 14:29:35
    冒泡排序 时间复杂度:O(N²) 稳定性:稳定 排序原理: 从前往后依次比较相邻的两个数据(如0:1 1:2 2:3 3:4 ... n:tail), 根据排序方向,将最大(最小)值移到最后面,一次遍历浮出一个数据, N次遍历...
  • 本文实例讲述了C语言排序算法之冒泡排序实现方法。分享给大家供大家参考,具体如下: 冒泡排序和改进的冒泡排序 /*------------------------------------------------------------------------------------------- ...
  • 冒泡排序C语言,运用“冒泡”的方法进行排序,是数据结构中常用的方法
  • 冒泡排序C语言详解

    2020-03-29 12:42:28
    } //*********************简单冒泡排序****************** void bubbleSort(int a[]) { int i, j; for (i = 0; i ; i++) { for (j = i + 1; j ; j++) if (a[i] > a[j]) swap(a, i, j); } } int main...
  • 双向冒泡排序 //双向冒泡排序 #include<stdio.h> #define MAXSIZE 1024 typedef struct { int key;//关键字项 char data;//其他数据项 }RecordType;//记录类型 void DBubbleSort(RecordType R[],int n) { ...
  • 冒泡排序-C语言版(带图详细)

    千次阅读 2022-04-18 15:56:34
    前言 相信大家在学习数据结构算法的时候经常会遇到的问题就是,老师讲解完这个算法思想,自己也听懂了,但一到自己写代码就写不出来,或者是即便自己模模糊糊的照着网上的代码自己写出来...冒泡排序的名字是因为元...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,154
精华内容 13,661
关键字:

冒泡排序c语言