精华内容
下载资源
问答
  • C语言 冒泡排序算法冒泡排序(Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该...

    C语言 冒泡排序算法

    冒泡排序(Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

    冒泡排序对n个项目需要O(n2)的比较次数,且可以原地排序。尽管这个算法是最简单了解和实作的排序算法之一,但它对于少数元素之外的数列排序是很没有效率的。

    冒泡排序是与插入排序拥有相等的执行时间,但是两种法在需要的交换次数却很大地不同。在最坏的情况,冒泡排序需要O(n2)次交换,而插入排序只要最多O(n)交换。冒泡排序的实现(类似下面)通常会对已经排序好的数列拙劣地执行(O(n2)),而插入排序在这个例子只需要O(n)个运算。因此很多现代的算法教科书避免使用冒泡排序,而用插入排序取代之。冒泡排序如果能在内部循环第一次执行时,使用一个旗标来表示有无需要交换的可能,也有可能把最好的复杂度降低到O(n)。在这个情况,在已经排序好的数列就无交换的需要。若在每次走访数列时,把走访顺序和比较大小反过来,也可以稍微地改进效率。有时候称为往返排序,因为算法会从数列的一端到另一端之间穿梭往返。

    d1bf9e134c89acd8244b017140f983c1.gif

    使用冒泡排序为一列数字进行排序的过程

    冒泡排序算法的运作如下:

    比较相邻的元素。如果第一个比第二个大,就交换他们两个。

    对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。

    针对所有的元素重复以上的步骤,除了最后一个。

    持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

    由于它的简洁,冒泡排序通常被用来对于程式设计入门的学生介绍算法的概念。

    关于冒泡排序的算法实现网上很多,本文采用C语言泛型实现:

    #include

    #include

    void swap(void *vp1, void *vp2, int size){

    char buffer[size];

    memcpy(buffer, vp1, size);

    memcpy(vp1, vp2, size);

    memcpy(vp2, buffer, size);

    }

    int cmp_int(const void *a , const void *b )

    {

    return *(int *)a - *(int *)b;

    }

    int cmp_double(const void *a , const void *b )

    {

    return *(double *)a > *(double *)b ? 1 : -1;

    }

    void bubbleSort(void *base, int n, int elemsize, int(*cmp)(const void *, const void *))

    {

    char *q = (char *)base;

    char *p = (char *)base + n * elemsize;

    while(p > q) {

    for(; q != p - elemsize; q += elemsize) {

    if(cmp(q, q + elemsize) > 0) {

    swap(q, q + elemsize, elemsize);

    }

    }

    q = (char *)base;

    p -= elemsize;

    }

    }

    int main(void)

    {

    //测试数据

    int arr1[] = {5, 4, 1, 3, 6, 12, 8, 22, 34,76};

    //冒泡排序

    bubbleSort(arr1, 10, sizeof(int), cmp_int);

    //打印排序结果

    int i;

    for(i = 0; i < 10; i++)

    printf("%d ", arr1[i]);

    printf("\n");

    double arr2[] = {5.4, 4.8, 1.2, 3.4, 6.7, 12.12, 8.6, 22.12, 34.5, 76.3};

    bubbleSort(arr2, 10, sizeof(double), cmp_double);

    for(i = 0; i < 10; i++)

    printf("%.2f ", arr2[i]);

    printf("\n");

    }

    运行结果如下:

    7774c8ae725e1bc7ec8d5c274d063c6b.png

    常规实现如下(C语言):

    #include

    void bubbleSort(int arr[], int count)

    {

    int i = count, j;

    int temp;

    while(i > 0) {

    for(j = 0; j < i - 1; j++) {

    if(arr[j] > arr[j + 1]){

    temp = arr[j];

    arr[j] = arr[j + 1];

    arr[j + 1] = temp;

    }

    }

    i--;

    }

    }

    int main()

    {

    //测试数据

    int arr[] = {5, 4, 1, 3, 6};

    //冒泡排序

    bubbleSort(arr, 5);

    //打印排序结果

    for(int i = 0; i < 5; i++)

    printf("%4d", arr[i]);

    }

    使用标志的冒泡排序

    如果已知数列基本有序,可采用一个标志,减少无谓的判断,提高效率

    void bubbleSort(int d[], int size) //假定两两交换发生在数组最后的两个位置

    {

    int exchange = size - 1;

    while(exchange) {

    //记录下发生数据交换的位置

    int bound = exchange;

    exchange = 0; //假定本趟比较没有数据交换

    for(int i = 0; i < bound; i++) {

    if(d[i] > d[i + 1]) {

    swap(&d[i], &d[i+1]);

    exchange = i;

    }

    }

    }

    }

    感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

    展开全文
  • C语言 冒泡排序算法 冒泡排序(Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说...
  • 冒泡排序算法,C语言冒泡排序算法详解

    千次阅读 多人点赞 2020-07-03 02:53:16
    冒泡排序是最简单的排序方法,理解起来容易。虽然它的计算步骤比较多,不是最快的,但它是最基本的,初学者一定要掌握。 冒泡排序的原理是:从左到右,相邻元素进行比较。每次比较一轮,就会找到序列中最大的一个或...

    冒泡排序是最简单的排序方法,理解起来容易。虽然它的计算步骤比较多,不是最快的,但它是最基本的,初学者一定要掌握。

    冒泡排序的原理是:从左到右,相邻元素进行比较。每次比较一轮,就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。

    以从小到大排序为例,第一轮比较后,所有数中最大的那个数就会浮到最右边;第二轮比较后,所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较,最后实现从小到大排序。

    比如对下面这个序列进行从小到大排序:
    90 21 132 -58 34

    第一轮:

    1. 90 和 21比,90>21,则它们互换位置:
      21 90 132 -58 34

    2. 90 和 132 比,90<132,则不用交换位置*。
      3)132 和 –58 比,132>–58,则它们互换位置:
      21 90 -58 132 34

    4)132 和 34 比,132>34,则它们互换位置:
    21 90 -58 34 132

    到此第一轮就比较完了。第一轮的结果是找到了序列中最大的那个数,并浮到了最右边。

    比较时,每轮中第 n 次比较是新序列中第 n 个元素和第 n+1 个元素的比较(假如 n 从 1 开始)。

    第二轮:

    1. 21 和 90 比,21<90,则不用交换位置。

    2. 90 和 –58 比,90>–58,则它们互换位置:
      21 -58 90 34 132

    3. 90 和 34 比,90>34,则它们互换位置:
      21 -58 34 90 132

    到此第二轮就比较完了。第二轮的结果是找到了序列中第二大的那个数,并浮到了最右边第二个位置。

    第三轮:

    1. 21 和 –58 比,21>–58,则它们互换位置:
      -58 21 34 90 132

    2. 21 和 34 比,21<34,则不用交换位置。

    到此第三轮就比较完了。第三轮的结果是找到了序列中第三大的那个数,并浮到了最右边第三个位置。

    第四轮:

    1. –58 和 21 比,–58<21,则不用交换位置。

    至此,整个序列排序完毕。从小到大的序列就是“–58 21 34 90 132”。从这个例子中还可以总结出,如果有 n 个数据,那么只需要比较 n–1 轮。而且除了第一轮之外,每轮都不用全部比较。因为经过前面轮次的比较,已经比较过的轮次已经找到该轮次中最大的数并浮到右边了,所以右边的数不用比较也知道是大的。

    废话也不多说了,直接上码

    #include <stdio.h>
    void main()
    { 
    	int num,n,temp;//定义变量
    	int a[100];   //初始化数组
        printf("您要重新排列多少个数:  \n");
    	scanf("%d",&num);
    	n=num;  //获取数组的长度    另外还有一种:n = sizeof(a) / sizeof(a[0]);  
    			/*a[0]是int型, 占4字节, 所以总的字节数除以4等于元素的个数*/
    	int i=0;
    	printf("请您输入排列的数:\n");
    	while ( scanf("%d",&a[i]) && num >1)  //循环向数组中存入数
    	{
    		i++;
    		num--;
    	}
    	printf("排列之前的顺序为:");
    	for (int length=0;length<n;length++)
    	{
    		printf("%3d",a[length]);
    	}
    	 for (int j=0; j<n-1; j++)  //比较n-1轮
        {
            for (int k=0; k<n-1-j; k++)  //每轮比较n-1-i次,
            {
                /*
    			if (a[k] < a[k+1]) //从大到小
                {
                    temp = a[k];
                    a[k] = a[k+1];
                    a[k+1] = temp;
                }
    			*/
    			if (a[k] > a[k+1]) //从小到大
    			{
    				temp = a[k];
    				a[k] = a[k+1];
    				a[k+1] = temp;
    			}
            }
    	 }
    	printf("\n");
    	printf("排列之后的顺序为:");
    	for (int len=0;len<n;len++)
    	{
    		printf("%3d",a[len]);
    	}
    	printf("\n");
    }
    

    结果如下图所示:
    在这里插入图片描述
    有人或许会问程序中,为什么每轮比较的次数是 j<n–1–i,而不是 j<n–1?


    因为冒泡排序有一个特点,这个程序是从小到大排序,所以第一轮排序以后,最大的数就会浮到最右面;第二轮排序以后,第二大的数会浮到倒数第二个位置;第三轮排序以后,第三大的数会浮到倒数第三个位置……也就是说,排序多少轮,就有多少个数字已经按排序要求排好了,它们不需要再比较。写 j<n–1 也可以,只不过程序在执行时多做了许多无用功。

    展开全文
  • 选择排序算法,C语言选择排序算法详解选择排序是一种简单直观的排序算法。它与冒泡排序很相似,都是比较 n-1 轮,每轮都是比较 n–1–i 次,每轮找出一个最大值或最小值。只不过,冒泡排序是将每轮找出的最值放到最...

    选择排序算法,C语言选择排序算法详解

    选择排序是一种简单直观的排序算法。它与冒泡排序很相似,都是比较 n-1 轮,每轮都是比较 n–1–i 次,每轮找出一个最大值或最小值。

    只不过,冒泡排序是将每轮找出的最值放到最右边,而选择排序是将每轮找出的最值放到最左边。并且在算法上,冒泡排序是将相邻的数进行逐个比较,以从小到大排序为例,只要前面的比后面的大,就互换这两个数,直到最后将最大的数“浮”到最右边,如此依次循环。而选择排序是先保存第一个元素的下标,然后后面所有的数依次与第一个元素相比,如果遇到更小的,则记录更小的那个数的下标,然后后面所有的数都依次与那个更小的数比较,直到最后将最小的数的下标找出来,然后再将这个数放到最左边,即与下标为 0 的数互换。如果最小的数的下标就是 0 那么就不用互换。

    所以,选择排序算法是先判断最小的数的下标是不是 0,如果不是则说明最小的数不是第一个元素,则将这个数与第一个元素互换位置,这样一轮下来最小的那个数就被找到并放到了最左边。

    在第二轮同样先保存新序列第二个元素的下标,后面所有的数依次与第二个元素相比较,如果遇到更小的则记录更小的那个数的下标,然后后面所有的数都依次与那个更小的数比较,直到最后又找到一个最小的,此时这个最小的在整个序列中是“第二小”。然后再判断这个数的下标是否等于 1,如果不等于 1 说明“第二小”的那个数不是第二个元素,则将这个数与第二个元素互换位置,这样第二轮下来就找到了“第二小”的那个数,并将它放到了第二个位置。如此循环,直到整个序列实现从小到大排序。

    如果是从大到小排序,那么就记录大的那个数的下标,每一轮找出一个最大的数放到左边。

    从上面的分析可以看出,选择排序和冒泡排序的另一个不同点是,冒泡排序只要遇到前面比后面大的就互换,而选择排序是比较一轮才互换一次,而且如果本轮中最小的就是最左边那个数则不用互换。所以从这个角度看,选择排序比冒泡排序的效率要高。而且通过上面对选择排序的分析发现,从逻辑上讲,与冒泡排序相比,选择排序更符合人的思维。

    下面来写一个程序,用选择排序实现一个序列的从小到大排序:

    # include

    int main(void)

    {

    int i, j; //循环变量

    int MinIndex; //保存最小的值的下标

    int buf; //互换数据时的临时变量

    int a[] = {5, 5, 3, 7, 4, 2, 5, 4, 9, 1, 8, 6};

    int n = sizeof(a) / sizeof(a[0]); //存放数组a中元素的个数

    for (i=0; i

    {

    MinIndex = i;

    for (j=i+1; j

    {

    if (a[MinIndex] > a[j])

    {

    MinIndex = j; //保存小的数的下标

    }

    }

    if (MinIndex != i) /*找到最小数之后如果它的下标不是i则说明它不在最左边, 则互换位置*/

    {

    buf = a[MinIndex];

    a[MinIndex] = a[i];

    a[i] = buf;

    }

    }

    printf("最终排序结果为:\n");

    for (i=0; i<12; ++i)

    {

    printf("%d ", a[i]);

    }

    printf("\n");

    return 0;

    }

    输出结果是:

    最终排序结果为:

    1 2 3 4 4 5 5 5 6 7 8 9

    通过程序可以看出,虽然选择排序比冒泡排序的效率高,逻辑上也更符合人的思维,但是程序相对更复杂,冒泡排序比选择排序在逻辑上要清晰一点,也稍微简单一点。

    编程帮,一个分享编程知识的公众号。跟着站长一起学习,每天都有进步。

    通俗易懂,深入浅出,一篇文章只讲一个知识点。

    文章不深奥,不需要钻研,在公交、在地铁、在厕所都可以阅读,随时随地涨姿势。

    文章不涉及代码,不烧脑细胞,人人都可以学习。

    当你决定关注「编程帮」,你已然超越了90%的程序员!

    erweima_biancheng.gif?v=1.6.45

    微信扫描二维码关注

    展开全文
  • 冒泡排序算法的原理如下:(升序) 比较相邻的元素,如果第一个比第二个大,就交换它们两个的值。 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。第一次冒泡,最后的元素会是最大的数。 重复以上的...

    冒泡排序算法的原理如下:(升序)

    1. 比较相邻的元素,如果第一个比第二个大,就交换它们两个的值。
    2. 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。第一次冒泡,最后的元素会是最大的数。
    3. 重复以上的步骤,除了最后一个。
    4. 每次排序的元素都会减少,直到没有任何一对元素需要比较。
    5. 冒泡排序最好的时间复杂度是O(n),最坏的时间复杂度是O(n^2)
    void bubbleSort(int* pArr, int n)
    {
    	int i, j, tmp;
    	/** 遍历数组 */
    	for(i=0; i<n-1; i++)
    	{
    		for(j=0; j<n-i-1; j++)
    		{
    			/** 如果当前的元素比后一个元素大, 则利用中间变量实现两值互换 */
    			if(pArr[j] > pArr[j+1])
    			{
    				tmp = pArr[j];
    				pArr[j] = pArr[j+1];
    				pArr[j+1] = tmp;
    			}
    		}
    	}
    }
    展开全文
  • 文章目录前言一、冒泡排序定义以及原理?二、具体代码实现总结 前言 冒泡排序:是对一连串数字进行升序排序或者降序排序的一种排序算法,排序算法有很多种,今天我们先来介绍其中的----冒泡排序 一、冒泡排序定义...
  • 最近学习JAVA , 想着用java实现这两个算法,一敲代码,就发现又忘记了一半, 还好还是一边分析一边回忆敲出来了。...冒泡算法 核心思想: 让每一对相邻的邻居比较 ,发现前面的比后面的大的就交换两个的位置 。...
  • 请教下C中对于数据多,处理效率较高的排序法及其实际如何编写,运用c语言排序法有选择法和冒泡法是最常见的。1冒泡法对10个数排序#include voidmain() {inta[10]; inti,j,t; printf("pleaseinput10numbers:\n");...
  • c语言冒泡排序(解析) 运行结果:
  • C语言排序算法详解

    2017-02-19 16:02:05
    冒泡排序法 交换排序法 插入排序法 折半(二分排序法) yuanli xing 东西就不在这里赘述了,直接上代码先,原理的东西都在代码上面有注释: sort.h#ifndef __SORT_H_ #define __SORT_H_//选择排序算法 extern void ...
  • 数据结构 - 冒泡排序法详解

    千次阅读 2017-01-24 23:36:39
    数据结构 - 冒泡排序法
  • 这是与冒泡排序特点类似的一种比较排序。该算法中,通过比较数组中相邻的(奇-偶)位置数字对,如果该奇偶对是错误的顺序(第一个大于第二个),则交换。下一步重复该操作,但针对所有的(偶-奇)位置数字对。如此...
  • 冒泡排序是一种很常见的简单排序。它依次扫描要排序的序列,比较两个相邻的元素,如果逆序就交换位置。每次经过扫描一趟后,未排序部分最大的元素就“冒泡”到了最上面。函数接口void bubble_sort1(int *a, int low,...
  • 详解C语言冒泡排序

    2019-10-31 19:27:30
    最近在复习C语言的知识,到了数组这里觉得冒泡排序很有意思,就想把关于冒泡排序的一些思路写出来。 对于一个已经定于的数组给定它任意的元素。然后我们对其排序。我这里我们使用冒泡排序。在这里我们先说一下什么是...
  • 冒泡排序C语言实现 - 源码详解

    千次阅读 2019-10-12 14:29:35
    冒泡排序 时间复杂度:O(N²) 稳定性:稳定 排序原理: 从前往后依次比较相邻的两个数据(如0:1 1:2 2:3 3:4 ... n:tail), 根据排序方向,将最大(最小)值移到最后面,一次遍历浮出一个数据, N次遍历...
  • 为了易用,我编写排序函数,这和直接在主调函数...冒泡排序法void sort(int * ar,int k) //ar指向数组名,k是元素个数{int i,j,temp;; i < k - ; i++){ //比较k-1趟就可以了; j < k - i -; j++){]){temp = ...
  • C语言--冒泡排序法(详细注释)

    万次阅读 多人点赞 2014-07-14 02:08:00
    冒泡排序 了,之后学到更多的算法也会写在博客里,也会添加最浅显易懂的注释,一方面方便自己以后回顾,另一方面也方便大家互相交流学习。 十个整型数的冒泡排序<由小到大> -- C语言 #include ...
  • 冒泡排序算法详解

    2016-01-23 17:39:05
    冒泡排序是我们平时生活中常用的,就是挨个比大小,所以相对其它算法比较好理解.冒泡排序就是小的往上冒或者大的往上冒,自己画个图就能明白了. 步骤如下:(假设从小到大排序) 1.iNum[n]是待排序的数组(3 2 4 1 5) 2....
  • 本文将教科书里的冒泡法改进下以提高排序效率,并提供标准函数接口,大家可以直接调用!
  • //简单冒泡排序 for ( i = 0 ; i < n - 1 ; i ++ ) for ( int j = 0 ; j < n - i - 1 ; j ++ ) { if ( strcmp ( str [ j ] , str [ j + 1 ] ) > 0 ) // 相当于前面的...
  • 关于选择排序与冒泡排序算法详解 本篇主要应对C语言初学者对冒泡排序和选择排序的一个初步介绍和认知 首先我们来认识下选择排序 那什么是选择排序呢?选择排序就是指在一推数组里每一次从待排序的数据元素中选出...
  • 面试题详解冒泡排序法

    千次阅读 2017-03-02 17:35:15
    小弟学过c语言的基础,在做php的开发。和各位大神是不可以比拟。 但是最近看了一些面试题...今天就是php的数组的冒泡排序: $mynumber=array(10,5,17,3,1,4,77,99,23,21); function Msort(array $number){ $sum=coun
  • C语言选择排序详解及其实现

    万次阅读 多人点赞 2016-06-10 21:48:51
    (我将冒泡排序的链接放到这里,有兴趣的可以看看,冒泡排序:http://blog.csdn.net/llzk_/article/details/51547923) 它的工作原理是每一次从无序组的数据元素中选出最小(或最大)的一个元素,存放在无序组的起始...
  • 选择法排序 选择法排序是指:如果要把一个数组从小到大排列,那么就从该数组中依次选择最小的数字来排序。从第一个数字开始,将第一个数字与数组中剩下数字中最小的那一个交换位置,然后将第二个数字与剩下数字中...
  • Java实现冒泡排序详解

    千次阅读 热门讨论 2021-04-20 15:00:40
    深度解析冒泡排序算法 public class MySort{ public static void bubbleSort(int array[]){ for (int i = 0; i < array.length; i++) { for (int j = 0; j < array.length - 1 - i; j++) { if(array[j]>...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 739
精华内容 295
关键字:

c语言冒泡排序法详解

c语言 订阅