排序算法系列--冒泡泡泡（C++）

最新推荐文章于 2022-03-09 17:57:23 发布
最新推荐文章于 2022-03-09 17:57:23 发布
阅读量713 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fenxinzi557/article/details/51732344
版权

不得不说，算法这个东西还是挺让人头疼的。。昨天中午忽然脑袋短路，一时竟想不起以前看过的冒泡算法的原理，看来还是没有理解透，中午躺床上睡不着了。。。。
于是，先把他想明白了再休息吧。。。。
冒泡算法1：

# include <iostream>
# include <ctime>
# define SIZE 11
using namespace std;
void bubble_sort(int a[], int n);

void bubble_sort(int a[], int n)
{
    int i=0, j=0, temp=0;
    for (j = 0; j < n; j++)
    {
        for (i = j+1; i < n; i++)
        {
            if(a[j] > a[i])
            {
                temp = a[j];
                a[j] = a[i];
                a[i] = temp;
            }
        }
    }
}

int main()
{
    int number[SIZE];
    srand(time(0));
    for(int m=0;m<SIZE;m++)
    {
        number[m] = (rand()%100);
    }
    int num=0;
    bubble_sort(number, SIZE);
    for (num = 0; num < SIZE; num++)
    {
        cout<<number[num]<<" ";
    }
}

这是我实现的最笨拙的冒泡算法，按《大话数据结构》书上来说，这不算是正宗的冒泡算法。。
他的原理很简单，第一层循环用来确定当前最小数的存放位置，这里为依次从前往后，第二层循环用来比较出当前的最小值。
冒泡算法2.
这个算法也是我刚开始犯迷糊的地方，其实如果想不明白只要在纸上自己写一个序列，然后把这个程序循环自己走完就能明白他的原理。

# include <iostream>
# include <ctime>
# define SIZE 11
using namespace std;
void bubble_sort(int a[], int n);

//void bubble_sort(int a[], int n)
//{
//  int i=0, j=0, temp=0;
//  for (j = 0; j < n; j++)
//  {
//      for (i = j+1; i < n; i++)
//      {
//          if(a[j] > a[i])
//          {
//              temp = a[j];
//              a[j] = a[i];
//              a[i] = temp;
//          }
//      }
//  }
//}
void bubble_sort(int a[],int n)
{
    int i=0, j=0, temp=0;
    for (j = 0; j < n-1; j++)
    {
        for (i = 0; i < n-j-1; i++)
        {
            if(a[i] > a[i+1])
            {
                temp = a[i];
                a[i] = a[i+1];
                a[i+1] = temp;
            }
        }
    }
}

int main()
{
    int number[SIZE];
    srand(time(0));
    for(int m=0;m<SIZE;m++)
    {
        number[m] = (rand()%100);
    }
    int num=0;
    bubble_sort(number, SIZE);
    for (num = 0; num < SIZE; num++)
    {
        cout<<number[num]<<" ";
    }
}

这是正宗冒泡排序的一种形式，第一层循环（j=0）过后，最大的数落在了最后，较小的数相应的都会有所提前，第一层循环（j=1）过后，次大的数落在倒数第二位，较小的数相应会有所提前，如此循环………….完成从小到大的排列。
这种形式还有另外一种变形，代码如下：

# include <iostream>
# include <ctime>
# define SIZE 11
using namespace std;
void bubble_sort(int a[], int n);

//void bubble_sort(int a[], int n)
//{
//  int i=0, j=0, temp=0;
//  for (j = 0; j < n; j++)
//  {
//      for (i = j+1; i < n; i++)
//      {
//          if(a[j] > a[i])
//          {
//              temp = a[j];
//              a[j] = a[i];
//              a[i] = temp;
//          }
//      }
//  }
//}
//void bubble_sort(int a[],int n)
//{
//  int i=0, j=0, temp=0;
//  for (j = 0; j < n-1; j++)
//  {
//      for (i = 0; i < n-j-1; i++)
//      {
//          if(a[i] > a[i+1])
//          {
//              temp = a[i];
//              a[i] = a[i+1];
//              a[i+1] = temp;
//          }
//      }
//  }
//}
void bubble_sort(int a[],int n)
{
    int i, j, temp,flag=0;
    for (j = 0; j < n; j++)
    {

        for (i = n-2; i >= j; i--)
        {
            cout<<flag++<<endl;
            if(a[i] > a[i+1])
            {
                temp = a[i];
                a[i] = a[i+1];
                a[i+1] = temp;
            }
        }
    }
}
int main()
{
    int number[SIZE];
    srand(time(0));
    for(int m=0;m<SIZE;m++)
    {
        number[m] = (rand()%100);
    }
    int num=0;
    bubble_sort(number, SIZE);
    for (num = 0; num < SIZE; num++)
    {
        cout<<number[num]<<" ";
    }
}

这种形式跟上一个原理一样，只不过这种做法是较小的数字会慢慢如同气泡一样浮到前面，此算法命名为冒泡的由来。
3.冒泡排序的优化
参考大话数据结构优化方法：
如果待排序的序列为｛2，1，3，4，5，6，7，8，9，10，11｝，我们会发现，除了第一个数和第二个数需要交换外，其余的并不需要交换，然而算法依然两两比较，做了好多无用功。
改进一下代码，增加一个标记变量flag来实现算法的改进，即当两两比较发现所有相邻的元素都是大小有序（即相邻两元素不再需要交换位置），则停止后面的比较，即认为此时序列已经完成排序。
代码如下：

# include <iostream>
//# include <ctime>
# define SIZE 11
using namespace std;
void bubble_sort(int a[], int n);

//void bubble_sort(int a[], int n)
//{
//  int i=0, j=0, temp=0;
//  for (j = 0; j < n; j++)
//  {
//      for (i = j+1; i < n; i++)
//      {
//          if(a[j] > a[i])
//          {
//              temp = a[j];
//              a[j] = a[i];
//              a[i] = temp;
//          }
//      }
//  }
//}
//void bubble_sort(int a[],int n)
//{
//  int i=0, j=0, temp=0;
//  for (j = 0; j < n-1; j++)
//  {
//      for (i = 0; i < n-j-1; i++)
//      {
//          if(a[i] > a[i+1])
//          {
//              temp = a[i];
//              a[i] = a[i+1];
//              a[i+1] = temp;
//          }
//      }
//  }
//}
void bubble_sort(int a[],int n)
{
    int i, j, temp,count=0;
    bool flag = true;
    for (j = 0; j < n && flag; j++)
    {
        flag = false;
        count++;//增加计数变量，用于查看循环进行次数
        for (i = n-2; i >= j; i--)
        {
            if(a[i] > a[i+1])
            {
                temp = a[i];
                a[i] = a[i+1];
                a[i+1] = temp;
                flag = true;
            }
        }
    }
    cout<<count<<endl;
}
int main()
{
    int number[SIZE] = {1,2,3,4,5,6,7,9,11,8,10};
    //srand(time(0));
    //for(int m=0;m<SIZE;m++)
    //{
    //  number[m] = (rand()%100);
    //}
    int num;
    bubble_sort(number, SIZE);
    for (num = 0; num < SIZE; num++)
    {
        cout<<number[num]<<" ";
    }
}

我们增加count变量用于查看循环进行了多少次，如果序列是{1,2,3,4,5,6,7,9,11,8,10}，则第一次循环，序列变为｛1,2,3,4,5,6,7,8,9,11,10｝,第二次循环，序列变为｛1,2,3,4,5,6,7,8,9,10,11｝,第三次循环，序列没有作数据交换（此时序列已经有序），所以标志变量flag = false；下面的循环不再进行，即count = 3;
这里写图片描述
分析与运行结果一致。。

fenxinzi557
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++Bubble sort冒泡排序的实现算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-19 443
C++Bubble sort冒泡排序的实现算法法C++Bubble sort冒泡排序的实现算法完整源码(定义，实现，main函数测试） C++Bubble sort冒泡排序的实现算法完整源码(定义，实现，main函数测试） #include <iostream> #include <vector> int main() { int n; bool swap_check = true; std::cout << "Enter the amount
cpp代码-//冒泡排序算法 //从左到右，循环地比较相邻元素，这样一轮下来，最值就会像泡泡般从左跑到最右边
07-14
**冒泡排序算法详解** 冒泡排序是一种简单直观的排序算法，它的基本思想是通过重复遍历待排序的序列，一次比较两个元素，如果他们的顺序（如从小到大）错误就把他们交换过来。遍历待排序的序列多次，直到没有任何...
c++实现起泡排序
Jpday的专栏
12-03 2031
#include using namespace std; int main() { void Bubble_Sort(int array[],int n); cout<<"Please input data number is:"; int n,i,*p; cin>>n; p=new int [n+1]; for(i=1;i<n+1;i++) cin>>p[i]; Bubble_Sort(p
C#冒泡泡算法
weixin_30344131的博客
01-06 92
代码如下： static void Main(string[] args) { int[] arr = new int[] { 87, 85, 89, 84, 76, 82, 90, 79, 78, 68 };//定义一个一维数组并赋值 Console.WriteLine("初始序列："); ...
C#控制台吹泡泡算法
weixin_30682415的博客
01-06 90
代码如下： static void Main(string[] args) { Bubbling(100, 100, "O", 1000); Console.ReadLine(); } /// <summary> /// 冒泡 ...
冒泡排序算法 (C++)
Python_programer的博客
12-09 583
今天我想分享一个C++编写的冒泡排序算法，其实和C语言的没多大区别，就是有了C++专属的输入输出流方式，希望对初学者有帮助！ //冒泡排序算法 #include&lt;iostream&gt; #include&lt;stdlib.h&gt; using namespace std; int main() { int a[5]; cout &lt;&lt;"please input...
c++冒泡排序算法
jkkkkkkksd的专栏
01-23 316
从第一个数不断往后，相邻两个数之间相互比较大小，若前者小于后者，则相互交换位置，一轮完成后，从第二个数重新开始，再次比较，以此重复，直到最后一个数。最坏的情况下，要比较（n-1）*/2次。。 // kspx.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include using namespace std; void kspx(int a[]
冒泡排序或起泡排序(C/C++)
weixin_45500953的博客
03-09 699
冒泡排序或起泡排序(C/C++) 代码如下： #include<stdio.h> //交换数值 void swap(int *p1, int *p2){//定义两个整型指针p1和p2，其中p1和p2均表示地址 int temp = *p1;//取出地址p1对应存储单元的值，并将其赋给整型变量temp *p1 = *p2;//取出地址p2对应存储单元的值，并将其存于地址p1对应的存储单元中 *p2 = temp;//将整型变量temp的值存于地址p2对应的存储单元中 } //对数组
冒泡算法精简理解
weixin_30622107的博客
05-21 110
组长安排的工作做完了，闲得蛋疼。重新理解下最经典的冒泡算法。 原理：比较相邻的两个数，如果第一个数比后一个要大，则交换位置。 其实原理很好理解了，一看就是写个循环。但是要交换几次呢。我们就拿最简单的排序来推理一下。 假设数组是正序的1~9，我们手动排序的话需要交换0次。这是最少的交换次数。 如果数组是倒序9~1，我们需要一个一个的，9和8交换，9和7交换。。。。9和1交换，9到了最后一位，...
排序——冒泡排序（C++实现）
线上幽灵
10-21 479
冒泡排序算法的基本思想：假设待排序长为n，从后往前两两比较相邻元素的值，如为逆序，则交换它们，直到序列比较完。我们称为一趟冒泡，结果将最小的元素交换到待排序列的第一个位置（关键字最小的元素如气泡一般逐渐往上“漂浮”直至“水面”，这就是冒泡排序名字的由来）。下一趟冒泡时，前一趟确定的最小元素不再参与比较，待排序列减少一个元素，每趟冒泡的结果把序列中最小元素放到了序列的最终位置，......，这样最多
冒泡排序的C++实现
03-05
文档提供了冒泡排序的C++实现算法
Leo的泡泡——算法笔记
学而不思则忘
05-20 446
题目描述： Leo临近高考，为了缓解心情，她蹲在鱼缸旁看小鱼吐泡泡。 看了一段时间，她发现了一些规律： 小鱼每次会吐出一个小泡泡o或者大泡泡O，这些吐出来的泡泡会垂直往上升，两个相连的小泡泡会合在一起成为大泡泡，两个相连的大泡泡会合在一起炸开，也就是没有泡泡了。 小鱼每次都等上一次的泡泡合并完才会吐下一个泡泡，现在Leo给出她记录的小鱼吐泡泡的顺序，你能帮她计算最后的泡泡序列吗 输入： 数据...
C++冒泡排序
huxyc的博客
06-25 103
用C++比用C可读性和方便性要强些。 #include<iomanip> #include<iostream> #include<vector> #include<ctime> using namespace std; #define VECTOR_SIZE 500 int main(int argc, char* argv[]) { /*cout << argv[argc - 1] << endl;*/ vector
交换式排序法之冒泡排序法实现-java版
Vincent
07-03 781
//这里涉及一个数组引用的传递，在DemoBubble类里面对Bubble类Sort方法调用传递了一个数组应用，在Sort方法里面对数组的更改都会更改实参。这就类似于C语言里面传递的数组地址。package com.PengRong.A;import java.util.*;public class DemoBubble { public static void main(String[] args
C++实现冒泡排序
专业^团队的博客
06-23 6299
Bubble Sort 即冒泡排序，这种写法相当于相邻的数字两两比较，并且规定：“谁大谁站右边”。经过 n−1 轮，数字就从小到大排序完成了。整个过程看起来就像一个个气泡不断上浮，这也是“冒泡排序法”名字的由来，先来理解算法思想： 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直
C++常见排序算法——冒泡排序算法
lengxuan001的博客
10-15 2万+
首先说一下冒泡排序的基本算法思想： 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 以从小到大排序为例：a[5]={3,5,4,1,0}; 先将3和5进行比较，已经是我们需要的正序，不需要交换位置； 再将5和4进行比较，不是正序，相互交换顺序，序列变为{3,4,5,1,0}。
C++简单排序算法之冒泡排序
热门推荐
zhengjuexi4456的博客
09-08 7万+
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。冒泡排序算法的运作如下：（从后往前）比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后
c++实现冒泡排序
点滴的岁月
05-31 4万+
冒泡排序：依次比较相邻的数据，将小数据放在前，大数据放在后；即第一趟先比较第1个和第2个数，大数在后，小数在前，再比较第2个数与第3个数，大数在后，小数在前，以此类推则将最大的数"滚动"到最后一个位置；第二趟则将次大的数滚动到倒数第二个位置......第n-1(n为无序数据的个数)趟即能完成排序。对冒泡排序算法进行简单的优化，用一个标记来记录在一趟的比较过程中是否存在交换，如果不存在交换则整个数组
C++第4版：数据排序方法详解-选择与冒泡排序
这一章主要探讨了两种常见的排序算法：选择排序和冒泡排序。 1. 选择排序： - 基本思想是每次从未排序的部分中找到最小（或最大）的元素，将其放到已排序序列的末尾。这个过程重复进行，直到所有元素都排好序。 -...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值