精华内容
下载资源
问答
  • C++中的冒泡排序 C++中的冒泡排序C++中的冒泡排序C++中的冒泡排序C++中的冒泡排序 C++中的冒泡排序 C++中的冒泡排序 C++中的冒泡排序
  • 冒泡排序c++

    2019-01-06 17:00:56
    冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从A到Z)错误就把他们交换过来。
  • 冒泡排序C++

    2012-12-04 14:27:11
    void bubble_sort(int array[],int n) {  int i,j,flag,temp;  for(i = 0; i ; i++)  {  flag = 1;  for(j = 0; j ; j++)  {  if(array[j] > array[j+1])  {  temp= array[j];...}
  • 冒泡排序c++

    2017-08-30 11:12:41
    交换排序—冒泡排序(Bubble Sort) 基本思想: 在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后...
    1. 交换排序—冒泡排序(Bubble Sort)
      基本思想:

    在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。

    算法的实现:

    #include<iostream>
    #include<string>
    using namespace std;
    
    void print(int a[],int n,int i){
    
        for(int j=0;j<n;j++){
            cout << a[j] << " ";
        }
        cout << endl;
    }
    
    void bubbleSort(int a[],int n){
        for(int i=0;i<n;i++){
            for(int j=0;j<n-i-1;j++){
                if(a[j] >a[j+1]){
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
            print(a,n,i);
        }
    } 
    int main(){
        int a[8]={9,7,6,5,4,3,2,1,};
        bubbleSort(a,8);
    }

    运行结果:
    7 6 5 4 3 2 1 9
    6 5 4 3 2 1 7 9
    5 4 3 2 1 6 7 9
    4 3 2 1 5 6 7 9
    3 2 1 4 5 6 7 9
    2 1 3 4 5 6 7 9
    1 2 3 4 5 6 7 9
    1 2 3 4 5 6 7 9

    展开全文
  • 冒泡排序C++实现

    2019-10-20 11:19:17
    冒泡排序C++实现 #include <iostream> using namespace std; //交换两个元素的值的方法 void swap(int *a, int *b) { int *temp = a; a = b; b = temp; } //冒泡排序 void bubbleSort(int arr[], int ...

    冒泡排序C++实现

    #include <iostream>
    using namespace std;
    
    //交换两个元素的值的方法
    void swap(int *a, int *b)
    {
        int *temp = a;
        a = b;
        b = temp;
    }
    
    //冒泡排序
    void bubbleSort(int arr[], int length)
    {
        for (int i = 1; i <= length; i++)
        {
            for (int j = 0; j < length - i; j++)
            {
                if (arr[j] > arr[j + 1])
                {
                    swap(arr[j], arr[j + 1]);
                }
            }
        }
    }
    
    int main()
    {
        int arr[6] = {9, 4, 7, 3, 1, 5};
        int length = sizeof(arr) / sizeof(arr[0]); //获取数组长度
        bubbleSort(arr, length);
        for (int i = 0; i < length; i++)
        {
            cout << arr[i] << endl;
        }
        return 0;
    }
    
    展开全文
  • 冒泡排序c++源程序

    2013-04-18 17:04:02
    冒泡排序c++源程序,编译通过,包含头文件。
  • 冒泡排序 C++

    千次阅读 2018-11-03 17:49:11
    一、说明:冒泡排序的原理在注释中,文中冒泡排序使用了模板来传入数据,详细情况看下面的测试代码。 二、测试代码 #include &amp;lt;iostream&amp;gt; #include &amp;lt;vector&amp;gt; ...

    一、冒泡排序

    1、冒泡排序

    从数组的右到左对数组进行两两比较排序,大的放到最右边。第一遍比较后最小的元素在最左边的0号位置,第二遍开始将第2小的数据放到1号位置,一直比较到只剩最后两个元素确认是否交换为止。

    2、优缺点

    优点:1、简单
    缺点:1、在各种情况下的比较次数都相等,效率低
    算法复杂度:O(n~n^2) 空间复杂度:O(n)+辅助变量空间

    二、测试代码

        #include <iostream>
        #include <vector>
        
        using namespace std;
        /******************************
        冒泡排序:从数组的右到左对数组进行两两比较排序,大的放到最右边。
        第一遍比较后最小的元素在最左边的0号位置,第二遍开始将第2小的数
        据放到1号位置,一直比较到只剩最后两个元素确认是否交换为止。
        优点:1、简单
        缺点:1、在各种情况下的比较次数都相等,效率低
        算法复杂度:O(n~n^2) 空间复杂度:O(n)+辅助变量空间
        ******************************/
        
        // 实现方法一
        template<typename T>
        void bubbleSort1(T data[], int n)
        {
            for(int i=0; i<n-1; i++)
            {
                for(int j=n-1; j>i; j--)
                {
                    if(data[j]<data[j-1])
                    {
                        T temp = data[j];
                        data[j] = data[j-1];
                        data[j-1] = temp;
                    }
                }
            }
        }
        
        // 实现方法二冒泡改进版
        template<typename T>
        void bubbleSort2(T data[], int n)
        {
            // 设置标志位用来查看是否发生交换,如果没有发生交换说明排序已经完成,不需要再进行排序
            // 这种情况发生的概率不多,这种改进需要额外保存一个变量,效果可能还不如第一种效果好
            bool flag = true;
            for(int i=0; i<n-1 && flag; i++)
            {
                flag = false;
                for(int j=n-1; j>i; j--)
                {
                    if(data[j]<data[j-1])
                    {
                        T temp = data[j];
                        data[j] = data[j-1];
                        data[j-1] = temp;
                        flag = true;
                    }
                }
            }
        }
        
        // 实现方法三
        template<typename T>
        void bubbleSort3(vector<T> &data)
        {
            for(int i=0; i<data.size()-1; i++)
            {
                for(int j=data.size()-1; j>i; j--)
                {
                    if(data[j] < data[j-1])
                    {
                        T temp = data[j];
                        data[j] = data[j-1];
                        data[j-1] = temp;
                    }
                }
            }
        }
        
        int main()
        {
            int tempArr[] = {0,4,3,5,6,7,9,8,2,1};
            int arrSize = sizeof(tempArr)/sizeof(tempArr[0]);
            cout << "arrSize=" << arrSize << endl;
            // bubbleSort1 test
            // bubbleSort1(tempArr,arrSize);
            // bubbleSort2(tempArr,arrSize);
            vector<int> tempVec(tempArr,tempArr+arrSize);
            bubbleSort3(tempVec);
            cout << "===========bubbleSort tempArr==========" << endl;
            for(int i=0; i<arrSize; i++)
            {
                cout << tempArr[i] << endl;
            }
            cout << "===========bubbleSort tempVec==========" << endl;
            for(int i=0; i<arrSize; i++)
            {
                cout << tempVec[i] << endl;
            }
            cout << "Hello World!" << endl;
            return 0;
        }
    

    三、测试结果

    在这里插入图片描述

    展开全文
  • 冒泡排序 C++实现

    2017-07-06 09:39:47
    冒泡排序
    #include <iostream>
    using namespace std;
    #define MAX_SIZE 8 
    int main()
    {
    		int arry[MAX_SIZE];
    		for(int i=0;i<MAX_SIZE;i++)
    				cin>>arry[i];         //随机输入
    		for(auto c:arry)
    				cout<<c<<" ";         //检测输入的结果
    		cout<<endl;                  //换行,结果清晰
    		bool flag=false; 			//标志位
    		for(int i=0;i<MAX_SIZE-1;i++)     //总共进行N-1次排序
    		{
    
    				for(int j=MAX_SIZE-1;j>i+1;j--)
    				{
    						if(arry[j]<arry[j-1])   //如果后面的比前面的小,则发生交换
    						{
    								int temp;
    								temp=arry[j];
    								arry[j]=arry[j-1];
    								arry[j-1]=temp;
    								flag=true;    //发生了交换,则标志位为真
    								continue;  //结束此循环 
    						}
    						else 
    								flag=false;  //未发生交换
    						
    				}
    				if(!flag)      //如果flag为假则未发生交换,则有序,结束循环
    						break;
    		}
    		for(auto c:arry)
    				cout<<c<<" ";
    		return 0;
    }
    

    展开全文
  • 冒泡排序c++实现

    2019-10-21 11:17:17
    冒泡排序的思想在之前python版本里已经写过了,这里就只给出冒泡排序c++实现版本,代码如下: #include<iostream> #include<vector> using namespace std; void display(vector<int> vec); ...
  • 冒泡排序C++模板实现

    2013-10-10 16:34:18
    冒泡排序C++模板实现 #include #include using namespace std; //冒泡排序 template void BubSort(T *begin, T *end) { T *pi, *pj; for (pi = end; pi > begin; pi--) for (pj = begin + 1; pj ; pj++) ...
  • 支持c++写的冒泡排序饿的的算法,性能怎么样需要最测试,纯属研究,谨慎下载
  • 冒泡排序 c++实现

    2017-12-21 17:24:59
    冒泡排序是最容易实现的算法,相信很多人能够熟练地打出,但为了排序系列的完整,还是把它写出来了
  • 选择冒泡排序,首先要知道冒泡排序的时间复杂度为o(n^2),空间复杂度为o(n)。本题中n最大为100,时间和空间都可以接受。 #include&amp;lt;iostream&amp;gt; using namespace std; int main() { ...
  • 排序算法之冒泡排序 C++和PHP实现

    千次阅读 2014-11-20 10:47:57
    冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。是最慢的排序算法。在实际运用中它是效率最低的算法。
  • } 代码注释: void BubbleSort(int a[],int size) { //外循环为排序趟数,size个数进行size-1趟排序 for(int i=0; i; ++i) { //内循环为每趟比较的次数,第 i趟比较size-i次 for(int j=0; j; ++j) { //...
  • 冒泡排序(Bubble sort) 思想:从左到右两两对比,大的往后移,每轮完成之后,数组中最大的数都会沉到数组末尾。 优缺点:稳定、不需要辅助和空间,但是效率太低 复杂度: 时间换空间,不需要额外的辅助空间 平均...
  • 冒泡排序C++实现+优化

    千次阅读 2014-08-03 10:58:11
    #include #include using namespace std; void BubbleSort(int *pdata,int length) { for (int i=1;i;i++) { for (int j=length-1;j>=i;j--) { if (pdata[j][j-1]) ... int temp=pdata[j
  • = head)//从右往左小数冒泡 43 { 44 q = p->prior; 45 if(p->data < q->data) 46 { 47 exchange = true;//发生了交换 48 swap(p->data,q->data); 49 p = q;//p往前移动 50 } 51 else p = p->prior;//未发生交换,...
  • 这次实现的是蛮力法中的两个例子,选择排序法和冒泡排序法,使用的编译环境是vs2013,下面对这两个算法做一个简单介绍,然后是两个算法的c++实现代码。  选择排序法比较的范围是整个列表,每次扫描结束找出最小的...
  • Bubble Sort (冒泡排序 C++)

    千次阅读 2013-02-06 15:52:12
    "Bubble Sort" is a simple way to sort elements. This sort employs a "bubbling strategy" to get the largetest element to the right. In a bubbling pass, pairs of adjacent elements are compared, the ele
  • 冒泡排序 C++ 实现的比较简洁的代码

    千次阅读 2012-08-28 11:49:57
    冒泡排序比起其它排序算法,是比较容易, 目前我认为的相当简洁的代码如下: #include "iostream.h" void main() { const int count = 10; int A[count] = {8, 2, 3, 4, 10, 2, 1, 3, 4, 9}; //定义一个...
  • 冒泡排序C++代码实现

    千次阅读 2020-08-30 10:29:01
    #include<iostream> #include<vector> using namespace std; void sort(vector<int> nums) { int i=0,j=0,n=nums.size(); int temp=0; for(int i=0;i<n-1;... temp=num.
  • 冒泡排序c++实现冒泡排序代码

    万次阅读 多人点赞 2018-06-29 16:02:29
    冒泡排序的基本思想:比较相邻的元素,如果反序则交换。通过第一趟排序能找出最大的元素,并使最大的元素移至最后一位,然后通过第二次排序使次大的元素移至倒数第二位,以此类推,直至所有元素有序。 程序代码如下...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,852
精华内容 13,540
关键字:

冒泡排序c++

c++ 订阅