冒泡算法理解

冒泡排序的思想：中心思想是两两交换。

1  冒泡算法各层的含义：

 第一层含义

第一层循环与i的初始值无关，而只与循环了多少次有关。

冒泡排序第一层循环的含义为：需要遍历多次数组，才能将这个数组排好序。

那到底需要遍历多少次数组，才能排好序呢？

 

第一次遍历，确定一个最值。

第二次遍历，确定第二个最值。

......

第num-1次遍历，确定第num-1最值。  Num-1个最值都确定了，自然整个数组也就排好序了。  

第一层循环含义为：需要遍历num-1次数组，才能将数组排好序。

通常定义为int j;  j是一个与i相关的变量，第2层循环需要用到第一层的i的值。

 

第二层循环要解决的问题

要解决的问题：待排序区域的起始和结尾位置。

而要解决这个问题，

首先，第一个要解决的便是：在进行这个循环时，数组已经排好了几个值。

 

其次，第二个要解决的便是：在数组中，待排序区域的其实和末尾位置分别是什么。

 

第一个要解决的问题与第一层循环已经进行了多少次有关。

第二个要解决的问题则与排序时遍历的方向有关。

 

2    冒泡排序算法

2.1

i =0

i =0;i<num-1;i++;      //在进行第i次循环时，已经排好i个数据分别是0,1,……i-1

//待排序的是a[i]…a[n-1]

voidBubbleSortBtoS(int A[],int num)  // 从数组末尾向数组开始遍历

{

int i, j;

         int temp=0;

         for (int i=0;i<num-1;i++)

         {

                   for (intj=num-1;j>i;j--)    //  待排的数据为i,i+1,...num-1    此处判断条件为j>i

                   {

                            if (A[j]<A[j-1])   //从大到小顺序排列;如果要求从小到大顺序则为if (A[j]>A[j-1])                          {

                                     temp=A[j];

                                     A[j]=A[j-1];

                                     A[j-1]=temp;

                            }

                   }

         }

}

 

i =0;i<num-1;i++;      //在进行第i次循环时，已经排好i个数据分别是n-1,n-2,……n-i

//待排序的是a[0]…a[n-i-1]

voidBubbleSortStoB(int A[],int num)  // 从数组开始向数组末尾遍历

{

         int i, j;

         int temp=0;

         for (int i=0;i<num-1;i++)

         {

for (int j=0;j<num-i-1;j++)//待排的数据为0,1,2,...,n-i-1 此处判断条件为 j<num-i-1

                   {

                            if (A[j]>A[j+1])  //从小到大排列

                            {

                                     temp=A[j];

                                     A[j]=A[j+1];

                                     A[j+1]=temp;

                            }

                   }

         }

}

 

2.2  i=1

 

总有人喜欢从i=1开始作为第一层循环的起始值，这是习惯问题，因此我们也分析下从1开始时的程序。

int i=1;i<num;i++      //冒泡算法遍历数组num-1次

                            //在进行第i次循环时,已经排好i-1个数据0,1,…,i-2待排序的是a[i-1]…a[n-1]

voidBubbleSortBtoS1(int A[],int num)  // 从数组末尾向数组开始遍历

{

int i, j;

         int temp=0;

         for (int i=1;i<num;i++)

         {

                   for (intj=num-1;j>=i;j--)    //  待排的数据为i-1,i,i+1,...num-1   此处为j>=i

                   {

                            if (A[j]<A[j-1])

                            {

                                     temp=A[j];

                                     A[j]=A[j-1];

                                     A[j-1]=temp;

                            }

                   }

         }

}

 

i =1;i<num;i++;         //在进行第i次循环时，已经排好i-1个数据分别是n-1,n-2,……n-i+1

//待排序的是a[0]…a[n-i]

voidBubbleSortStoB1(int A[],int num)  // 从数组开始向数组末尾遍历

{

         int i, j;

         int temp=0;

         for (int i=1;i<num;i++)

         {

                   for (intj=0;j<=num-i-1;j++)     // 待排的数据为0,1,2,...,n-i-1,n-i    此处为j<=num-i-1

                   {

                            if (A[j]>A[j+1])

                            {

                                     temp=A[j];

                                     A[j]=A[j+1];

                                     A[j+1]=temp;

                            }

                   }

         }

}

 

3   冒泡算法的改进：

思想：待排序区域末尾位置,是需要记住的,使用一个参数记录此末尾位置 遍历一次数组，末尾位置减一;

3.1简化从前往后遍历

i =0;i<num-1;i++;      //在进行第i次循环时，已经排好i个数据分别是0,1,……i-1

//待排序的是a[i]…a[n-1]

voidBubbleSortStoB_Tail(int A[],int num)  //tail参数记录末尾位置

{

int i, j;

         int temp=0;

         int tail=num-1;

         for (int i=0;i<num-1;i++)

         {

                   for (intj=0;j<tail;j++)     // 待排的数据为0,1,2,...,tail      实则tail==num-i-1

                   {

                            if (A[j]>A[j+1])

                            {

                                     temp=A[j];

                                     A[j]=A[j+1];

                                     A[j+1]=temp;

                            }

                   }

                   tail--;

         }

}

第二层循环与i值无关

第一层循环含义为遍历次数;

第二层循环含义为遍历待排序数据区域

 

3.2 增设是否有序标志

 

voidBubbleSortBtoS_Modify(int A[],int num) // 从数组末尾向数组开始遍历

{

int i, j;

         bool bSwap=false;

         int temp=0;

         for (int i=0;i<num-1;i++)

         {

 

                   for (intj=num-1;j>i;j--)    //  待排的数据为i,i+1,...num-1    此处判断条件为j>i

                   {

                            if (A[j]<A[j-1])

                            {

                                     bSwap=true;

                                     temp=A[j];

                                     A[j]=A[j-1];

                                     A[j-1]=temp;

                            }

                   }

 

                   if (!bSwap)               //   设置是否交换标志以提前退出

                   {

                            break;

                   }

         }

}