精华内容
下载资源
问答
  • 本文实例为大家分享了C++实现冒泡排序的具体代码,供大家参考,具体内容如下 一、思路: 冒泡排序算法原理: 1.比较相邻的元素。如果第一个数比第二个数大,就交换他们两个。 2.对每一对相邻元素做同样的工作,从...
  • C++实现冒泡排序

    2021-06-23 20:19:58
    Bubble Sort 即冒泡排序,这种写法相当于相邻的数字两两比较,并且规定:“谁大谁站右边”。经过 n−1 轮,数字就从小到大排序完成了。整个过程看起来就像一个个气泡不断上浮,这也是“冒泡排序法”名字的由来,先来...

    Bubble Sort 即冒泡排序

    这种算法相当于相邻的数字两两比较,并且规定:“谁大谁站右边”。经过 n−1 轮,数字就从小到大排序完成了。整个过程看起来就像一个个气泡不断上浮,这也是“冒泡排序法”名字的由来,先来理解算法思想:

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

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

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

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

    代码:

    #include <iostream>
    using namespace std;
    const int INIT = 10;
    class Bubble {
    public:
    	void bubble(int arr[],int n) {
    	
    		for (int i = 0; i < n-1; i++)
    		{
    			for (int j = 0; j < n - 1 - i; j++) {
    				if (arr[j] > arr[j + 1]) {
    					//左大右小,则交换,保持始终右边最大
    					int tmp = arr[j];//tmp暂存大值
    					arr[j] = arr[j+1];
    					arr[j+1] = tmp;
    				}
    			}
    		}
    	}
    };
    int main()
    {
    	Bubble b1;
    	int n = 0;
    	int arr[INIT];
    	cout << "Input n=";
    	cin >> n;
    	for (int i = 0; i < n; i++)
    		//依次输入元素
    		cin >> arr[i];
    
        b1.bubble(arr,n);
    	for (int j= 0; j < n; j++)
    		cout << arr[j] <<"	";
    	return 0;
    }

    测试用例:

    输入 n=5  并依次输入5 4 3 2 1

    运行截图如下

    冒泡排序算法优化:

    最外层的 for 循环每经过一轮,剩余数字中的最大值仍然是被移动到当前轮次的最后一位。这种写法相对于第一种写法的优点是:如果一轮比较中没有发生过交换,则立即停止排序,因为此时剩余数字一定已经有序了。

    看下动图演示:

    #include <iostream>
    using namespace std;
    const int INIT = 10;
    class Bubble {
    public:
    	void bubble(int arr[], int n) {
    
    		for (int i = 0; i < n - 1; i++)
    		{
    			for (int j = 0; j < n - 1 - i; j++) {
    				if (arr[j] > arr[j + 1]) {
    					//左大右小,则交换,保持始终右边最大
    					int tmp = arr[j];//tmp暂存大值
    					arr[j] = arr[j + 1];
    					arr[j + 1] = tmp;
    				}
    			}
    		}
    	}
    	void BubbleSort(int arr[], int n)
    	{
    		int i = 0;
    		int tmp = 0;
    		for (i = 0; i < n - 1; i++)//确定排序趟数
    		{
    			int j = 0;
    			int flag = 0;
    			for (j = 0; j < n - 1 - i; j++)//确定比较次数
    			{
    				if (arr[j] > arr[j + 1])
    				{
    					//交换
    					tmp = arr[j];
    					arr[j] = arr[j + 1];
    					arr[j + 1] = tmp;
    					flag = 1;   // 置1,表示发生了交换
    				}
    			}
    			if (flag == 0)//如果没有交换过元素,则已经有序
    			{
    				 break;
    			}
    		}
    	}
    };
    int main()
    {
    	Bubble b1;
    	int n = 0;
    	int arr[INIT];
    	cout << "Input n=";
    	cin >> n;
    	for (int i = 0; i < n; i++)
    		//依次输入元素
    		cin >> arr[i];
    
    	b1.BubbleSort(arr, n);
    	for (int j = 0; j < n; j++)
    		cout << arr[j] << "	";
    	return 0;
    }

    测试用例:

    输入 n=5  并依次输入2 3 5 6 4

    运行截图如下

    时间复杂度 & 空间复杂度


    冒泡排序从 1956 年就有人开始研究,之后经历过多次优化。它的空间复杂度为O(1),时间复杂度为 O(n^2),第二种冒泡排序由于经过优化,最好的情况下只需要 O(n) 的时间复杂度。

    最好情况:在数组已经有序的情况下,只需遍历一次,由于没有发生交换,排序结束。

    最差情况:数组顺序为逆序,每次比较都会发生交换。

    正如 Donald E. Knuth(19741974 年图灵奖获得者)所言:“冒泡排序法除了它迷人的名字和导致了某些有趣的理论问题这一事实外,似乎没有什么值得推荐的。”

    展开全文
  • 冒泡排序: (无序区,有序区)。从无序区通过交换找出最大元素放到有序区前端。 选择排序思路: /* 比较相邻的元素。如果第一个比第二个大,就交换他们两个。 对每一对相邻元素作同样的工作,从开始第一对到结尾的...

    冒泡排序

    (无序区,有序区)。从无序区通过交换找出最大元素放到有序区前端。

    冒泡排序思路:

    /*

    1. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
    2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的
      元素会是最大的数。
    3. 针对所有的元素重复以上的步骤,除了最后一个。
    4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
      */

    冒泡排序完整源码

    void BubbleSort(vector<int>
    展开全文
  • C++篇——C++实现冒泡排序和选择排序算法摘要冒泡法代码运行结果选择排序法代码运行结果 摘要 本文通过C++实现了两类基础且经典的排序算法(冒泡法和选择排序法)。 冒泡法 代码 #include <iostream> using ...

    C++篇——C++实现冒泡排序和选择排序算法

    摘要

    本文通过C++实现了两类基础且经典的排序算法(冒泡法选择排序法)。

    冒泡法

    代码

    #include <iostream>
    
    using namespace std;
    
    int main()
    {
    
        /** 需要排序的数组 */
        double array[] = {5.8,2.3,4.9,10.8,-50.2,20.4,19.5,23.8,10.9,100.2};
        /** 数组的长度 */
        int array_length = sizeof(array)/sizeof(double);
        cout << "length of array is : " << array_length << endl;
    
        // 冒泡法进行降序排序
        double temp;
    
        for(int i = 0; i < array_length-1; i++){
            for(int j=0; j < array_length-i-1; j++){
                if(array[j]<array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    
        // 输出排序结果
        int i = 0;
        while( i < array_length){
            cout << array[i] << "\t";
            i ++ ;
        }
        cout << endl; 
    }
    
    
    

    运行结果

    length of array is : 10
    100.2   23.8    20.4    19.5    10.9    10.8    5.8     4.9     2.3     -50.2
    
    

    选择排序法

    代码

    #include <iostream>
    
    using namespace std;
    
    int main()
    {
    
        /** 需要排序的数组 */
        double array[] = {5.8,2.3,4.9,10.8,-50.2,20.4,19.5,23.8,10.9,100.2};
        /** 数组的长度 */
        int array_length = sizeof(array)/sizeof(double);
        cout << "length of array is : " << array_length << endl;
        
        // 选择排序法进行排序
        double temp;
        for(int i=0; i < array_length - 1; i++){
            for(int j=i+1; j < array_length; j ++ )
            {
                if(array[j] > array[i]){
                    temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
    
        // 输出排序结果
        int i = 0;
        while( i < array_length){
            cout << array[i] << "\t";
            i ++ ;
        }
        cout << endl;
    }
    
    

    运行结果

    length of array is : 10
    100.2   23.8    20.4    19.5    10.9    10.8    5.8     4.9     2.3     -50.2
    
    

    by CyrusMay 2021 01 18

    一颗葡萄有多甜美
    用尽了所有的
    图腾和语言
    描写
    ——————五月天(仓颉)——————

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

    万次阅读 2016-05-31 17:10:47
    冒泡排序:依次比较相邻的数据,将小数据放在前,大数据放在后;即第一趟先比较第1个和第2个数,大数在后,小数在前,再比较第2个数与第3个数,大数在后,小数在前,以此类推则将最大的数"滚动"到最后一个位置;第二...

    冒泡排序:依次比较相邻的数据,将小数据放在前,大数据放在后;即第一趟先比较第1个和第2个数,大数在后,小数在前,再比较第2个数与第3个数,大数在后,小数在前,以此类推则将最大的数"滚动"到最后一个位置;第二趟则将次大的数滚动到倒数第二个位置......第n-1(n为无序数据的个数)趟即能完成排序。对冒泡排序算法进行简单的优化,用一个标记来记录在一趟的比较过程中是否存在交换,如果不存在交换则整个数组已经有序退出排序过程,反之则继续进行下一趟的比较。

    平均时间复杂度:O(n2),效率不高,适合小数据排序

    空间复杂度:O(1)  (用于交换)

    稳定性:稳定

    //冒泡排序,两种方法冒泡排序的最小时间代价θ(n),最大时间代价,和平均时间代价均为θ(n²)。,2016.5.29
    #include <iostream>
    using namespace std;
    void swap(int array[], int i, int j)
    {
    	int temp = array[i];
    	array[i] = array[j];
    	array[j] = temp;
    }
    void BubbleSort1(int array[], int n)
    {
    	for (int i = 0; i < n-1; i++)
    	{
    		for (int j = i + 1; j < n-1; j++)
    		{
    			if (array[i]>array[j])
    				swap(array, j, i);//每次i后面的元素比array[i]小就交换。
    		}
    	}
    }
    void BubbleSort2(int array[], int n)
    {
    	for (int i = 0; i < n - 1; i++)
    	{
    		for (int j = n - 1; j >= i;j--)
    		{
    			if (array[j - 1]>array[j])//从后面到i个元素两两比较,把小的不断上顶
    				swap(array, j, j - 1);
    		}
    	}
    }
    void main()
    {
    	int arr[13];
    	cout << "请输入要排序的元素:" << endl;
    	for (int i = 0; i < 13; i++)
    	{
    		cin >> arr[i];
    	}
    	//cout << "排序前的无序数组元素" << arr[i] << endl;
    	BubbleSort1(arr, 13);
    	cout << "排序后的数组元素" << endl;
    	for (int i = 0; i < 13; i++)
    	{
    		cout << arr[i] << endl;
    	}
    	BubbleSort2(arr, 13);
    	cout << "排序后的数组元素" << endl;
    	for (int i = 0; i < 13; i++)
    	{
    		cout << arr[i] << endl;
    	}
    	system("pause");
    }


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

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

    2017-03-05 12:30:30
    文档提供了冒泡排序C++实现算法
  • C++实现冒泡排序

    千次阅读 2018-05-24 23:03:55
    下面Jungle用C++实现两种冒泡排序法: ①传统的冒泡排序法sort_Bubble:内外两轮循环,前后两个数据依次比较; ②改进的冒泡排序法sort_Bubble2:同样是内外两次循环,但用一个标记来标识当前这一轮是否发生数据...
  • 1.冒泡排序 #include <ioatream> #include <vector> #include <algorithm> void bubbleSort(std::vector<int> &vec) { for (size_t i = 0;i+1 < vec.size();++i) { for ...
  • 冒泡排序:通过不断比较数组中两个数的位置,按照一定顺序(升序或者降序)将每个数字一点一点排好. 举例说明 需要排序数组: 1 2 3 4 5 要求将其从大到小重新排序,则步骤为: Round 1:从第一位数字开始进行...
  • c/c++实现冒泡排序

    2019-12-09 15:14:29
    冒泡排序 - 依次比较相邻两元素,若前一元素大于后一元素则交换之,直至最后一个元素即为最大;然后重新从首元素开始重复同样的操作,直至倒数第二个元素即为次大元素;依次类推。如同水中的气泡,依次将最大或最小...
  • C++ 实现冒泡排序 #include<iostream> #include<vector> using namespace std; void bubblesort(vector<int> &nums) { int i = 0, j = 0 , temp = 0; for (int i = 0; i < nums.size();...
  • 插入排序、冒泡排序、归并排序、快速排序四种排序方式的C++实现,各写成了一个函数,主函数中可以选择调用那一个。初始化数组时用的是随机种子srand((int)time(0))。在宏中定义数组大小。
  • C++实现冒泡排序

    2020-05-07 21:35:18
    //利用冒泡排序实现数据小到大排序 int arr[10] = {2,4,6,8,1,3,7,5,9,0}; int len = sizeof(arr)/sizeof(arr[0]); //排序前结果 cout << "冒泡排序前数组元素顺序:" << " " ; for(int i=0...
  • C++实现冒泡排序(升序排序)

    千次阅读 2020-03-13 21:39:48
    直接上代码: #include<... //对冒泡排序实现升序排序 int arr[6] = { 2,4,3,6,1,5 }; int b = sizeof(arr) / sizeof(arr[0]);//定义数组中元素的个数; cout << "原数组为:" << endl...
  • include #include using namespace std; int main() { int a[7] = {2,4,3,6,5,8,7};//7个数组元素 int temp;中间变量 for (int i = 0; i { for (int j = i+1; j {  if (a[i] > a[i + 1]) ...te
  • #include<iostream> using namespace std; void bubbleSort(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]>... }
  • C++实现冒泡排序以及优化

    千次阅读 2018-08-13 17:38:19
    冒泡排序(Bubble Sort)基本思想: 两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止。 冒泡排序的基本流程: 1.比较相邻的元素,如果前一个比后一个大,就把它们两个调换位置。 2.对每一对...
  • 文章目录使用c/c++实现冒泡排序算法和比较排序算法的效率实现目的冒泡法排序和比较排序的实现方法普通比较排序算法冒泡排序算法结论 使用c/c++实现冒泡排序算法和比较排序算法的效率 实现目的 通过对比冒泡法排序和...
  • 直接上代码了! #include<iostream>...//冒泡排序 void bubbleSort(int *arr,int len) { for (int i = 0; i < len - 1; i++) { for(int j = 0;j < len - i - 1;j++) if (arr[j] > ...
  • C++语言实现冒泡排序算法

    千次阅读 2019-04-22 17:05:04
    冒泡排序算法为最简单的排序算法,易于实现,也容易理解,下面为实现代码: #include <iostream> using namespace std; void sort(int *arr,int length) //传入数组首地址和数组长度 { int temp; for ...

空空如也

空空如也

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

c++实现冒泡排序

c++ 订阅