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

    2017-03-05 12:30:30
    文档提供了冒泡排序C++实现算法
  • C++ 冒泡排序算法实现代码,用C++编写的冒泡排序算法代码
  • C++写了以上三种排序算法,对初学数据结构的同学一个参考
  • 冒泡排序C++)完整代码

    千次阅读 2021-12-02 09:33:48
    第一天:冒泡排序 文章目录算法学习一、冒泡排序原理?二、核心代码三、算法复杂度分析 一、冒泡排序原理? 1、从后往前依次比较相邻的元素。若是要按照升序排序,则后面的元素比前面的小,就交换这2个元素;降序则...

    算法学习

    本人机械科研dog一枚,对算法感兴趣。这是我自学算法的记录。
    第一天:冒泡排序

    一、冒泡排序原理?

    1、从后往前依次比较相邻的元素。若是要按照升序排序,则后面的元素比前面的小,就交换这2个元素;降序则相反。

    2、对每一对相邻元素作同样的工作,从第一对到最后一对。进行一轮比较交换下来,最后的元素就会是最小(或最大)的数了,这个数就不用参与后面的比较操作了。

    3、针对所有的元素重复以上的步骤。

    4、持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
    例子如下
    在这里插入图片描述

    二、核心代码

    该代码已经进过测试,稳定有效

    //函数写在Algorithm这个类里面了,并且是用模板方式编写
    //这是为了函数能适应各种类型的数据
    template<class T1>
    vector<T1> Algorithm::bubblesort(vector<T1> array)
    {
        int len = array.size();
        for(int i=0;i<len-1;i++)//n-1次冒泡
        {
            for(int j = 0;j<len-1-i;j++)//每一次冒泡需要两两比较len—1-i次
            {
                //交换两数操作
                int tem =  array[j+1];
                if(array[j] < array[j+1])//从小到大就大于号,从大到小就小于号
                {
                    array[j+1] = array[j];
                    array[j] = tem;
                }
    
            }
        }
        return  array;
    
    }
    

    三、算法复杂度分析

    冒泡排序因为进行了两次嵌套循环,其复杂度是O(n2)。这种复杂度对于大量数据的排序所花费的时间是不能忍受的,所以用的并不多,下一节将要学习最常用的排序算法:快速排序,其平均算法复杂度为O(nlogn)

    展开全文
  • 冒 泡排 序的c++代码实现
  • C++排序算法:冒泡排序_代码 template< class T> void swaps(T& a, T& b) { T temp = a; a = b; b = temp; return; } class Myset { private: int* arr; int size; public: Myset() { arr = ...

    C++排序算法:冒泡排序_代码

    template< class T>
    void swaps(T& a, T& b) {
    	T temp = a;
    	a = b;
    	b = temp;
    	return;
    }
    class Myset {
    private:
    	int* arr;
    	int size;
    public:
    	Myset() {
    		arr = new int[1]();
    		size = 0;
    	}
    
    	~Myset() {
    		if (arr) {
    			delete[]arr;
    		}
    	}
    	int getsize() {
    		return this->size;
    	}
    	int* getarr() {
    		return this->arr;
    	}
    	bool adds(int i);
    	void sort_bubble_ver_one();
    }
    
    bool Myset::adds(int i) {
    	if (size == 0) {
    		arr[0] = i;
    		size++;
    		return true;
    	}
    	else {
    		int* prr = new int[size + 1];
    		for (int i = 0; i < size; i++) {
    			prr[i] = arr[i];
    		}
    		prr[size] = i;
    		delete[]arr;
    		arr = prr;
    		size++;
    		return true;
    	}
    }
    

    声明:

    void sort_bubble_ver_one();
    

    冒泡排序—的---具体定义:

    void Myset::sort_bubble_ver_one() {
    	int i = 0;
    	int j = 0;
    
    	for (i = 1; i < this->size; i++) {
    		for (j = this->size - 1; j > i - 1; j--) {
    			if (this->arr[j] < this->arr[j - 1]) {
    				swaps(this->arr[j], this->arr[j - 1]);
    			}
    			else {
    				continue;
    			}
    		}
    		//this->print();
    	}
    	return;
    }
    

    运行结果:
    在这里插入图片描述

    展开全文
  • 冒泡排序具体C++代码实现(dev测试通过),能输出每趟排序后的结果,排序过程中比较的总次数以及最终的排序结果,输入形式为空格隔开的连续正整数,输入-1表示结束输入
  • 冒泡排序

    在这里插入图片描述

    #include <iostream>
    using namespace std;
    int main()
    // 冒泡排序
    {
       
       
        int arr[9]={4,2,8,0,5,7,3,9,1};
        // 循环len-1次
        for (int i =0;i<9-1;i++)
    
    
        {
            // 循环比较len-i次
            for(int j=0; j<9-i-1;j++)
    
            {
                // 交换相邻的元素
                if (arr[j]>arr[j+1])
                {
                    int temp =arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
         for (int i =0;i<9;i++)
         {
             cout<<arr[i]<<endl;
         }
    
      
        
        system("pause") ;
        return 0;
    }
    
    展开全文
  • 冒泡排序c++

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

    千次阅读 2020-12-08 16:58:39
    冒泡排序c++实现冒泡排序代码 冒泡排序的基本思想: 冒泡排序的核心是对所有相邻数组元素的值进行比较,如果是逆序(a[i]>a[i+1]),则两者交换,最终达到有序。 步骤: (1)比较第一个数a[0]和第二个数a[1],...

    【冒泡排序】c++实现冒泡排序代码

    冒泡排序的基本思想

    冒泡排序的核心是对所有相邻数组元素的值进行比较,如果是逆序(a[i]>a[i+1]),则两者交换,最终达到有序。

    步骤

    (1)比较第一个数a[0]和第二个数a[1],如果a[0]>a[1],则,两个数组元素的值交换;然后接着比较第二个数a[1]和第三个数a[2],以此类推,直到第n-1个数a[n-1]与第n个数a[n]比较为止。这个过程是第一趟冒泡排序,其结果是将数组中最大的值放到了最后一个位置上。

    (2)第二趟冒泡排序,是对前n-1个元素做第一步的处理,结果使第二大的数放在倒数第二个位置上。

    (3)重复上述过程,共经过n-1趟冒泡排序后,排序结束。

    程序代码如下:

    #include<iostream>
    using namespace std;
     
    void print(int arr[], int n)
    {  
        for(int j= 0; j<n; j++)
    	{  
               cout<<arr[j] <<"  ";  
            }  
        cout<<endl;  
    }  
     
    void BubbleSort(int arr[], int n)
    {
        for (int i = 0; i < n - 1; i++)
    	{
                for (int j = 0; j < n - i - 1; j++)
    	        {
                        if (arr[j] > arr[j + 1]) 
    			{
                                int temp = arr[j];
                                arr[j] = arr[j + 1];
                                arr[j + 1] = temp;
                            }
                     }
             }
    }
     
    int main()
    {  
        int s[10] = {8,1,9,7,2,4,5,6,10,3};  
        cout<<"初始序列:";  
        print(s,10);  
        BubbleSort(s,10);  
        cout<<"排序结果:";  
        print(s,10);  
        system("pause"); 
    } 
    

    时间复杂度:O(n^2) 空间复杂度: O(1) 稳定排序

    展开全文
  • 冒泡排序C++实现(代码详解)

    千次阅读 2020-04-06 10:23:22
    完整代码: #include<iostream> using namespace std; #define num 100 int s[num]; void BubbleSort(int a[],int size) { for(int i=0; i<size-1; ++i) { for(int j=0; j<size-1-i; ++j) { if(a[j...
  • 冒泡排序算法C++

    2021-07-28 22:55:33
    冒泡排序算法比较简单,就是从左到右两两比较大小,比如升序排序,则把较大元素放到后面,第一轮结束后,开始第二轮比较排序;第二轮到第n-1个元素,一只到第n-1轮到比较最开始的两个元素则终止比较, 下面实现代码...
  • 数据结构冒泡排序

    2019-07-06 10:53:45
    C++版本,面向对象 数据结构冒泡排序代码 详细的注释说明 需要用Visual Studio 2013以上版本打开
  • 冒泡排序C++实现

    2019-03-03 18:54:02
    数据结构-冒泡排序法的C++实现工程,基于Visual Stdio2017
  • c++冒泡排序代码

    2015-03-24 10:51:27
    简单可用的一个c++冒泡排序代码 方便大家来学习一个
  • 冒泡排序c++实现

    2020-03-07 20:14:48
    冒泡排序简介 冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换,也就是说该...
  • C++排序算法之冒泡排序源码
  • 冒泡排序C++实现

    2018-03-06 23:08:12
     它和选择排序的区别就是,选择排序的交换操作是在外循环中进行的,而冒泡排序的交换操作是在内循环中进行的。另外,选择排序不稳定,而冒泡排序稳定。  冒泡排序的最好时间复杂度为O(n^2),平均时间复杂度也是O(n^...
  • #include<iostream> using namespace std; void BubbleSort(int *arr, int len) { for (int i = 0; i < len-1; i++) for (int j = 0; j < len - i - 1; j++) { //如果j>... arr.
  • 冒泡排序(Bubble sort) 思想:从左到右两两对比,大的往后移,每轮完成之后,数组中最大的数都会沉到数组末尾。 优缺点:稳定、不需要辅助和空间,但是效率太低 复杂度: 时间换空间,不需要额外的辅助空间 平均...
  • 冒泡排序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.
  • 冒泡排序:通过不断比较数组中两个数的位置,按照一定顺序(升序或者降序)将每个数字一点一点排好. 举例说明 需要排序数组: 1 2 3 4 5 要求将其从大到小重新排序,则步骤为: Round 1:从第一位数字开始进行...
  • 奇偶冒泡排序

    2016-03-30 22:08:21
    奇偶冒泡排序
  • 冒泡排序是一种流行但低效的排序算法,第一次循环将最小的数放在数组第一位,第二次循环将次最小数放在数组第二位… 伪代码 C++代码 #include using namespace std; void bubbleSort(int array[],int len); ...
  • C++实现冒泡排序

    2021-10-30 11:25:38
    这里采用输入10个整形数进行冒泡排序 #include<iostream> using namespace std; int main(){ int i,j,t,a[10]; //定义整形变量及整形数组 //从键盘中输入10个数 cout<<"请输入十个数"<<...
  • 冒泡排序C++示例代码

    2020-08-21 20:51:26
    #include<functional> #include<utility> #include<exception> #include<iostream> using namespace std; using uint = unsigned int; template<typename T>... .
  • 冒泡排序——C++代码

    2020-06-08 17:50:21
    课程的随堂作业,C语言的,用dev就能运行,萌新代码,勿喷,仅仅帮助不想写作业的朋友方便一下,反正老师也不会仔细检查的

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,097
精华内容 10,038
关键字:

冒泡排序c++代码

c++ 订阅