精华内容
下载资源
问答
  • 实现冒泡排序算法

    2019-02-14 15:32:54
    冒泡排序(Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果...冒泡排序算法的原理:(从后往前) 1、比较相邻的元素。如果第一个比第二个大,就交换他们两个。 2、对每...

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

    这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端,故名。

    冒泡排序算法的原理:(从后往前)

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

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

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

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

    /**
    *    实验题目:
    *        实现冒泡排序算法
    *    实验目的:
    *        领会冒泡排序的过程和算法设计
    *    实验内容:
    *        设计程序,实现冒泡排序算法。用相关数据进行测试,并
    *    输出各趟的排序结果。
    */

    #include <stdio.h>

    #define MAX_LEN     (100)                       //  最大长度

    typedef int key_type;                           //  定义关键字类型为int
    typedef char info_type;
    typedef struct
    {
        key_type key;                               //  关键字项
        info_type data;                             //  其他数据项,类型为info_type
    }rec_type;                                      //  查找元素的类型

    /*-----------------x和y交换------------------*/
    void swap_rec(rec_type &x, rec_type &y)         //  引用类型
    {
        rec_type tmp = x;
        x = y;
        y = tmp;
    }

    /*-----------------创建顺序表------------------*/
    void create_list(rec_type recs[], key_type keys[], int n)
    {
        int i;

        for(i = 0; i < n; i++)                      // recs[0...n-1]存放排序记录
            recs[i].key = keys[i];
    }

    /*-----------------输出顺序表------------------*/
    void disp_list(rec_type recs[], int n)
    {
        int i;

        for(i = 0; i < n; i++)
            printf("%d ", recs[i].key);

        printf("\n");
    }

    /*-----------------以下运算针对堆排序的程序------------------*/
    /*-----------------创建顺序表------------------*/
    void create_list1(rec_type recs[], key_type keys[], int n)
    {
        int i;

        for(i = 1; i <= n; i++)                     // recs[1...n]存放排序记录
        {
            recs[i].key = keys[i - 1];
        }
    }

    /*-----------------输出顺序表------------------*/
    void disp_list1(rec_type recs[], int n)
    {
        int i;

        for(i = 1; i <= n; i++)
        {
            printf("%d ", recs[i].key);
        }
        printf("\n");
    }

    #include <stdbool.h>

    /*-----------------对recs[0...n-1]按递增有序进行冒泡排序---------------------*/
    static void bubble_sort(rec_type recs[], int n)
    {
        int i;
        int j;
        bool exchange;

        for(i = 0; i < n - 1; i++)                      //  循环趟数
        {
            exchange = false;                           //  一趟前exchange置为假
            for(j = n - 1; j > i; j--)                  //  归位recs[i],循环n-i-1次
            {
                if(recs[j].key < recs[j - 1].key)       //  相邻两个元素反序时
                {
                    swap_rec(recs[j], recs[j - 1]);     //  将这两个元素交换
                    exchange = true;                    //  一旦有交换,exchange置为真
                }
            }
            printf("   i = %d: 归位元素%d, 排序结果: ", i, recs[i].key);
            disp_list(recs, n);
            if(!exchange)                               //  本趟没有发生交换,中途结束算法
                return;
        }
    }

    int main(int argc, char *argv[])
    {
        int n = 10;
        key_type a[] = {6, 8, 7, 9, 0, 1, 3, 2, 4, 5};
        rec_type recs[MAX_LEN];

        create_list(recs, a, n);
        printf("排序前: ");
        disp_list(recs, n);
        bubble_sort(recs, n);
        printf("排序后: ");
        disp_list(recs, n);

        return 0;
    }
    测试结果:

    排序前: 6 8 7 9 0 1 3 2 4 5
       i = 0: 归位元素0, 排序结果: 0 6 8 7 9 1 2 3 4 5
       i = 1: 归位元素1, 排序结果: 0 1 6 8 7 9 2 3 4 5
       i = 2: 归位元素2, 排序结果: 0 1 2 6 8 7 9 3 4 5
       i = 3: 归位元素3, 排序结果: 0 1 2 3 6 8 7 9 4 5
       i = 4: 归位元素4, 排序结果: 0 1 2 3 4 6 8 7 9 5
       i = 5: 归位元素5, 排序结果: 0 1 2 3 4 5 6 8 7 9
       i = 6: 归位元素6, 排序结果: 0 1 2 3 4 5 6 7 8 9
       i = 7: 归位元素7, 排序结果: 0 1 2 3 4 5 6 7 8 9
    排序后: 0 1 2 3 4 5 6 7 8 9

    展开全文
  • 文章目录使用c/c++实现冒泡排序算法和比较排序算法的效率实现目的冒泡法排序和比较排序的实现方法普通比较排序算法冒泡排序算法结论 使用c/c++实现冒泡排序算法和比较排序算法的效率 实现目的 通过对比冒泡法排序和...

    使用c/c++实现冒泡排序算法和比较排序算法的效率

    实现目的

    通过对比冒泡法排序和普通的比较排序,阐述冒泡法的排序效率,从而达到更好的掌握冒泡法的目的

    冒泡法排序和比较排序的实现方法

    普通比较排序算法

    #include <iostream>
    #include <vector>
    
    using namespace std;
    
    /**
     * @brief    normal_sort
     *
     *     normal compare algorithm to sort data sequence form smallest ---> biggest
     *
     * @param    vec
     */
    void normal_sort(vector<int> &vec)
    {
    	int i, j;
    	int size;
    	int temp;
    
    	size = vec.size();
    
    	for(auto v : vec)
    	{
    		cout << v << " ";
    	}
    	cout << endl;
    	cout << endl;
    
    	for(i=0; i<size-1; ++i)
    	{
    		for(j=i+1; j<size; ++j)
    		{
    			if(vec.at(i) > vec.at(j) )
    			{
    				temp = vec.at(i);
    				vec.at(i) = vec.at(j);
    				vec.at(j) = temp;
    			}
    		}
    
    		for(auto v : vec)
    		{
    			cout << v << " ";
    		}
    		cout << endl;
    	}
    }
    
    int main(int argc, char **argv)
    {
    	vector<int> intvec;
    	vector<int> intvec1;
    
    	vector<int>().swap(intvec);
    	vector<int>().swap(intvec1);
    	intvec.push_back(4);
    	intvec.push_back(5);
    	intvec.push_back(7);
    	intvec.push_back(1);
    	intvec.push_back(8);
    	intvec.push_back(3);
    
    	intvec1.push_back(1);
    	intvec1.push_back(2);
    	intvec1.push_back(3);
    	intvec1.push_back(4);
    	intvec1.push_back(5);
    	intvec1.push_back(6);
    
    	cout << "num: the bigger is down to bottom, and the smaller is up to the top" << endl;
    	normal_sort(intvec);
    	cout << "num1: if sequence is alredy sort, just run once time" << endl;
    	normal_sort(intvec1);
    
    	return 0;
    }
    

    执行结果

    tony@Tech:~/linux/fight$ ./normal_sort 
    num: the bigger is down to bottom, and the smaller is up to the top
    4 5 7 1 8 3 
    
    1 5 7 4 8 3 
    1 3 7 5 8 4 
    1 3 4 7 8 5 
    1 3 4 5 8 7 
    1 3 4 5 7 8 
    num1: if sequence is alredy sort, just run once time
    1 2 3 4 5 6 
    
    1 2 3 4 5 6 
    1 2 3 4 5 6 
    1 2 3 4 5 6 
    1 2 3 4 5 6 
    1 2 3 4 5 6 
    

    冒泡排序算法

    #include <iostream>
    #include <vector>
    
    using namespace std;
    
    /**
     * @brief    bubble_sort
     *     
     *     bubble algorithm to sort data sequence form smallest ---> biggest
     *
     * @param    vec
     */
    void bubble_sort(vector<int> &vec)
    {
    	bool flag;
    	int i, j;
    	int size;
    	int temp;
    
    	size = vec.size();
    
    	for(auto v : vec)
    	{
    		cout << v << " ";
    	}
    	cout << endl;
    	cout << endl;
    
    	for(i=size-1, flag=true; i>1 && flag; --i)
    	{
    		flag = false;
    
    		for(j=0; j<i; ++j)
    		{
    			if(vec.at(j) > vec.at(j+1) )
    			{
    				temp = vec.at(j);
    				vec.at(j) = vec.at(j+1);
    				vec.at(j+1) = temp;
    				flag = true;
    			}
    		}
    
    		for(auto v : vec)
    		{
    			cout << v << " ";
    		}
    		cout << endl;
    	}
    }
    
    int main(int argc, char **argv)
    {
    	vector<int> intvec;
    	vector<int> intvec1;
    
    	vector<int>().swap(intvec);
    	vector<int>().swap(intvec1);
    	intvec.push_back(4);
    	intvec.push_back(5);
    	intvec.push_back(7);
    	intvec.push_back(1);
    	intvec.push_back(8);
    	intvec.push_back(3);
    
    	intvec1.push_back(1);
    	intvec1.push_back(2);
    	intvec1.push_back(3);
    	intvec1.push_back(4);
    	intvec1.push_back(5);
    	intvec1.push_back(6);
    
    	cout << "num: the bigger is down to bottom, and the smaller is up to the top" << endl;
    	bubble_sort(intvec);
    	cout << "num1: if sequence is alredy sort, just run once time" << endl;
    	bubble_sort(intvec1);
    
    	return 0;
    }
    

    执行结果

    tony@Tech:~/linux/fight$ ./bubble_sort 
    num: the bigger is down to bottom, and the smaller is up to the top
    4 5 7 1 8 3 
    
    4 5 1 7 3 8 
    4 1 5 3 7 8 
    1 4 3 5 7 8 
    1 3 4 5 7 8 
    num1: if sequence is alredy sort, just run once time
    1 2 3 4 5 6 
    
    1 2 3 4 5 6 
    tony@Tech:~/linux/fight$ gedit normal_sort.cpp 
    tony@Tech:~/linux/fight$ 
    

    结论

    通过比较两种算法的差异得知:

    • 冒泡排序算法:先把最大的值沉到最低下,最小的值一步一步以冒泡的方式向前移动,而如果已经排序好的序列,只需要执行一次,效率是最高的。

    • 比较排序:不管原来是否排好序,都是按照固定的次数排序,执行次数是固定的
      counter=n(n1)2counter = \frac{n*(n-1)}{2}

    展开全文
  • Java简单实现冒泡排序算法

    千次阅读 热门讨论 2018-10-17 16:57:54
    java实现冒泡排序算法 依此比较相邻两个数,小的数放在前面,大的数放在后面 - 第一趟比较第1,2个数,小前大后;比较第2,3个数,小前大后,直至比较到把其中最大数放到最右端 - 第一趟之后,最后一个一定最大,...

    1、原理

    • 比较两个相邻的元素,将值大的元素交换到右端。

    2、思想

    • 依此比较相邻两个数,小的数放在前面,大的数放在后面
    • 第一趟比较第1,2个数,小前大后;比较第2,3个数,小前大后,直至比较到把其中最大数放到最右端
    • 第一趟之后,最后一个一定最大,比较第二趟,第二趟第一个不参与,把第二大的数放到倒数第二个位置
    • 第二趟之后,倒数第二个数第二大,第三趟最后两个数不参与
    • 依此类推,每一趟比较次数-1

    3、示例

    1. 数组如下:
    int[] arr = {6,3,8,2,9,1}
    
    1. 具体执行如下:
      冒泡排序趟数和排序次数执行图
    2. 备注
    • N个数字排序,进行 N-1趟排序
    • 每趟排序次数为 N-i-1次
    • 双重循环 外层控制趟数,内层控制每一趟排序次数

    4、代码实现

    package com.tmf;
    
    public class Test16 {
    	public static void main(String[] args) {
    		int[] arr = {6,3,8,2,9,1};
    		sort(arr);
    		for (int i : arr) {
    			System.out.print(i+" ");
    		}
    	}
    	public static void sort(int[] arr) {
    		for(int i=0;i<arr.length-1;i++)
    			for(int j=0;j<arr.length-1-i;j++) {
    				if(arr[j]>arr[j+1]) {
    					int temp = arr[j];
    					arr[j] = arr[j+1];
    					arr[j+1]=temp;
    				}
    			}
    	}
    }
    
    展开全文
  • 下面是使用Python实现冒泡排序算法的事例代码。

    下面是使用Python实现冒泡排序算法的事例代码。

    # 冒泡排序
    def bubbleSort(numbers): #冒泡算法的实验
        for j in xrange(len(numbers) -1, -1, -1):
            for i in xrange(j):
                if numbers[i] > numbers[i+1]: #把数值小的数字放到顶端
                    numbers[i], numbers[i+1] = numbers[i+1], numbers[i]
                print numbers
    
    def main(): #主函数
        numbers = [23, 12, 9, 15, 6]
        bubbleSort(numbers)
    if __name__ == '__main__':
        main() 
    展开全文
  • python实现冒泡排序算法

    千次阅读 多人点赞 2019-04-28 08:42:00
    冒泡排序,一个经典的排序算法,因在算法运行中,极值会像水底的气泡一样逐渐冒出来,因此而得名。 冒泡排序的过程是比较两个相邻...python实现冒泡排序: defbubble_sort(nums): foriinrange(len(nums)-1): f...
  • JavaScript实现冒泡排序算法

    千次阅读 多人点赞 2019-03-20 13:29:04
    一、冒泡排序 冒泡排序是一种非常基础的...下面我们用JS实现冒泡排序。 二、JS实现 1、创建待排序数组 var arr = [4,23,100,9,7,49,36,57]; 2、确定轮数 假设数组中有n个数,则需要n轮,而每一轮中比较的次数都要减...
  • java实现冒泡排序算法

    千次阅读 2018-08-30 13:29:26
    前面我们把冒泡排序算法详细的讲解了下,现在我们用java来实现以下这个算法 上代码 package ttt; public class BubbleSort { public static int[] BubbleSort(int[] theArray) { int tmp; for(int i = 0; i...
  • C语言实现冒泡排序算法的动态展示

    千次阅读 2018-05-22 17:34:33
    学习C语言有几天了,第一个分享程序:实现冒泡排序算法原理的简单动画展示,动画原理是最简单的清屏重绘。环境是WIN764,EGE库,CODEBLOCK 13.12。欢迎大神指正,能接受轻拍,很基础的东西,也能接受伸手党。我的...
  • 编写函数,实现冒泡排序算法。 def bubble(num_list): for i in range(len(num_list)): for j in range(i): if num_list[j] > num_list[i]: num_list[j], num_list[i] = num_list[i], ...
  • Python 实现冒泡排序算法

    千次阅读 2019-04-04 00:29:25
    冒泡排序(bubble sort): 原理: 重复的遍历要排序的数列, 一次... 冒泡排序算法如下: 对每一对相邻元素做相同的工作, 到最后, 最后的元素就是最大的 针对所有的元素重复以上步骤, 除了最后一个 持续每...
  • PIC单片机实现冒泡排序算法

    千次阅读 2017-03-04 12:45:34
    编写子程序paixu,实现1Byte数的顺序排列。待排序的10个二进制数(自定义...编写子程序,调用宏定义,使用冒泡排序算法实现排序。 1、冒泡排序算法 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,
  • JAVA实现冒泡排序算法

    千次阅读 2014-08-04 21:51:53
    1、冒泡排序算法思想
  • go实现冒泡排序算法

    2018-08-30 13:40:09
    前面我们讲了冒泡算法的大致含义,今天我们要使用go语言来...//冒泡排序 func bubbleSort(theArray[] int)[]int{ for i := 0; i&lt;len(theArray); i++ { for j :=0; j&lt;len(theArray)-1; j++ { ...
  • 数据结构: C语言实现冒泡排序算法

    千次阅读 2018-06-04 20:23:18
    C语言实现冒泡排序算法:#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; void swap(int* number, int i, int j); int main() { int number[100]; int quantity; int m = 0; int n = 0; ...
  • 用C++语言实现冒泡排序算法

    千次阅读 2019-04-22 17:05:04
    冒泡排序算法为最简单的排序算法,易于实现,也容易理解,下面为实现代码: #include <iostream> using namespace std; void sort(int *arr,int length) //传入数组首地址和数组长度 { int temp; for ...
  • 使用递归算法实现冒泡排序算法 import random def diguimaopao(alist): isChange=0 for i in range(len(alist)-1): if alist[i]>alist[i+1]: alist[i],alist[i+1]=alist[i+1],alist[i] ...
  • 用Python实现冒泡排序算法

    千次阅读 2018-09-09 21:50:06
    1.冒泡排序算法原理 # 冒泡排序要排序n个数(假设为升序排列), 由于每遍历一趟只排好一个数字 即把最大数排到最后 # 则需要遍历n-1趟,所以最外层循环是要循环n-1次 # 每完成一趟遍历后,下趟需要比较的数字就会...
  • 使用C语言实现冒泡排序算法

    千次阅读 2019-02-15 00:52:23
    冒泡排序 冒泡排序属于交换排序的一种。所谓交换,就是根据序列中两个关键字的比较结果来确定这两个记录在序列中的位置 冒泡排序的基本思想: 假设一个待排序列长度为N,从后往前(或从前往后)两两比较元素的值,若...
  • 在vivado上用verilog实现冒泡排序算法

    千次阅读 2019-04-28 23:45:40
    设计验证冒泡排序算法。给出设计程序、测试程序、时序仿真结果及分析说明。 二.冒泡排序原理 冒牌排序是将一个数组,按照从小到大进行排列。如下图所示: 假设初始数组元素排列为【8、7、6、5、4、3、2、1】。 经过...
  • MATLAB实现冒泡排序算法

    万次阅读 2018-09-11 20:46:46
    本文转载自头条文章原文章地址 1、bubble_sort.m function y=bubble_sort(x) x_len=length(x); for i=1:x_len-1  for j=1:x_len-i  if(x(j)&gt;x(j+1))  [x(j),x(j+1)]=swap(x(j),x(j+1));......
  • java 数组实现冒泡排序,小到大排序//冒泡排序法,小到大排序public class TestArray { public static void main(String args[ ]){ int i , j ; int a[ ] = { 5,9,6,8,7}; for ( i = 0 ; i ; i
  • 单链表实现冒泡排序算法

    千次阅读 2016-10-15 19:54:29
    下面实现主要采用交换指针的方法,其中附加有单链表及其相关的实现 [cpp] view plain copy #include    struct Node;    typedef struct Node *PtrToNode;  typedef ...
  • C语言实现冒泡排序算法(升序)

    千次阅读 2017-09-12 20:29:48
    有升序或者降序来进行冒泡排序(注意万一在面试中,面试官有问到冒泡排序,要问清楚面试官是用什么顺序来进行冒泡排序的)这里默认是用升序来进行排序的。   2、冒泡排序思路(第一层)是先从第一个数开始冒泡...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 84,153
精华内容 33,661
关键字:

实现冒泡排序算法