冒泡排序算法

1、 冒泡排序基本思想

交换相邻两个数，如果不满足排序条件，那么就交换。每一次遍历数组后，那么最后一个元素必然是最大（小）的元素。如：{4,3,5,1}，按照从大到小排序。

排序范围【0~3】，橙色为需要交换的元素，红色为当前排序范围的最大元素。

voidBubbleSort1(int *data, int left, int right)C++代码：
#include <iostream>
namespace mySort
{
         //冒泡排序1
         {
                   intn = (right - left + 1);
                   for(int i = 0; i < n; ++i)
                            for(int j = 1; j <= right-i; ++j)
                                     if(data[j - 1] > data[j])
                                               std::swap(data[j- 1], data[j]);
         }
         //改进1
         voidBubbleSort2(int * data, int left, int right)
         {
                   boolflag = true;
                   intn = right - left + 1;
                   intk = n;
                   while(flag)
                   {
                            flag= false;
                            for(int i = 1; i < k; ++i)
                            {
                                     if(data[i - 1] > data[i])
                                     {
                                               std::swap(data[i- 1], data[i]);
                                               flag= true;
                                     }
                            }
                            --k;
                   }
         }
         //改进2
         voidBubbleSort3(int * data, int left, int right)
         {
                   boolflag = true;
                   intn = right - left + 1;
                   intk = n;
                   while(flag)
                   {
                            flag= false;
                            inttmp = 0;
                            for(int i = 1; i < k; ++i)
                            {
                                     if(data[i - 1] > data[i])
                                     {
                                               std::swap(data[i- 1], data[i]);
                                               flag= true;
                                               tmp= i;
                                     }
                            }
                            k= tmp;
                   }
         }
};
int main()
{
         inta[] = {1};
         //mySort::BubbleSort1(a,0, 1);
         //mySort::BubbleSort2(a,0, 5);
         mySort::BubbleSort3(a,0, 0);
         return0;
}

 

 

后面是两种改进算法，请读者慢慢体会。

时间复杂度

算法1：任何情况都是O（N*N）

改进的算法2和3：最好O（N），普通和最坏O（N*N）