关于刷题入门(冒泡、选择排序)总结


简单题刷了一定数量以后,肯定会遇到排序的一些题要进行排序才能解决,排序先从这两种简单的排序掌握,在去接触快速排序和归并排序。

冒泡排序:

冒泡排序:顾名思义就是 小的数往上面冒,大的数往下沉(升序)。当然也可以反过来进行(降序)。

冒泡排序是常用的一种排序方法,其基本方法就是逐次比较。即一次比较两个数,若它们的顺序错误,则它们交换;重复进行,直到没有需要交换为止。

以升序为例:

            1、比较相邻数字的大小,若第一个数比第二个数大,则相互交换;
           
            2、对每一对相邻的数作相同的工作,那么最后的数应该是最大的数;
           
            3、针对所有数(除了最后一个)重复上述步骤,直到没有任何一对数字需要比较为止。
           
            需要注意的是,第3条中所谓的“最后一个”是指前几步中已经处理过的最大的数,而不是整个数列的最后一个数
           
            例如,将下列数列用冒泡排序法从小到大重新排列;
           
                                  48 37 64 96 75 12 26 48
                                 
                                           每次排序后数列的变化如下:
                                           
                                                    第一次排序:37 48 64 75 12 26 48 96   第一次排序之后 最大的已经到了最后面(最下面)
                                                    
                                                             第二次排序:37 48 64 12 26 48 75 96  第二次排序之后,第二大的到了倒数第二个位置 (往下也是这样)
                                                             
                                                                      第三次排序:37 48 12 26 48 64 75 96 ……
                                                                      
                                                                               第四次排序:37 12 26 48 48 64 75 96 ……
                                                                               
                                                                                                    :
                                                                                                    
                                                                                                                         :
                                                                                                                        
                                                                                                                                              :
                                                                                                                                             
                                                                                                                                                        经过一系列过程,最终数列次序为:12 26 37 48 48 64 75 96.
                                                                                                                                                       
                                                                                                                                                        冒泡排序原理弄清之后,接下来就是代码实现了:
                                                                                                                                                       
                                                                                                                                                       

                                                                                                                                                        //冒泡排序
                                                                                                                                                        //设数组a 有n个元素
                                                                                                                                                        int t;
                                                                                                                                                        for(i=0;i<n-1;i++)//n个数的数列总共扫描n-1次
                                                                                                                                                        {
                                                                                                                                                        for(j=0;j<n-i-1;j++)//每一趟扫描到a[n-i-2]与a[n-i-1]比较为止结束
                                                                                                                                                        {
                                                                                                                                                        if(a[j]>a[j+1])//后一位数比前一位数小的话,就交换两个数的位置(升序)
                                                                                                                                                        {
                                                                                                                                                        t=a[j+1];
                                                                                                                                                        a[j+1]=a[j];
                                                                                                                                                        a[j]=t;
                                                                                                                                                        }
                                                                                                                                                        }
                                                                                                                                                        }
                                                                                                                                                        

                                                                                                                                                       
                                                                                                                                                       
                                                                                                                                                       
                                                                                                                                                        ### 选择排序:
                                                                                                                                                       
                                                                                                                                                        选择法排序是相对好理解的排序算法。假设要对含有n个数的序列进行升序排列,算法步骤是:
                                                                                                                                                       
                                                                                                                                                           1、从数组存放的n个数中找出最小数的下标(算法见下面的“求最值”),然后将最小数与第1个数交换位置;
                                                                                                                                                           
                                                                                                                                                              2、除第1个数以外,再从其余n-1个数中找出最小数(即n个数中的次小数)的下标,将此数与第2个数交换位置;
                                                                                                                                                              
                                                                                                                                                                 3、重复步骤1  n-1趟,即可完成所求。
                                                                                                                                                                 
                                                                                                                                                                 
                                                                                                                                                                 //选择排序
                                                                                                                                                                 //设数组a 为待排序数组
                                                                                                                                                                 int k,i,j;
                                                                                                                                                                 for(i=0;i<n-1;i++)         /*处理n-1趟*/
                                                                                                                                                                 {
                                                                                                                                                                 k = i;      /*总是假设此趟处理的第一个(即全部数的第i个)数最小,k记录其下标*/
                                                                                                                                                                 for(j=i+1;j<n;j++)
                                                                                                                                                                 {
                                                                                                                                                                 if(a[j] < a[k])
                                                                                                                                                                 k = j; 
                                                                                                                                                                 }
                                                                                                                                                                 if (k != i)
                                                                                                                                                                 { 
                                                                                                                                                                 t = a[i]; 
                                                                                                                                                                 a[i] = a[k]; 
                                                                                                                                                                 a[k] = t; 
                                                                                                                                                                 }
                                                                                                                                                                 } 

                                                                                                                                                                 
                                                                                                                                                                 
                                                                                                                                                                 
                                                                                                                                                                 本文详细举例讲了冒泡排序,在刷题前期中 会冒泡排序了,基本上就很少用到选择排序,所以对于选择排序没有详细讲解。


文章作者: Cone
版权声明: 本博客所有文章除特別声明外,均采用 CC BY-NC-ND 4.0 许可协议。转载请注明来源 Cone !
  目录