旅游专区

当前位置:金沙7868com > 旅游专区 > 排序系列,冒泡排序

排序系列,冒泡排序

来源:http://www.jilawu.com 作者:金沙7868com 时间:2019-11-29 11:25

感觉高层比较安静人少,但是低层是不是出事儿比较好跑……大家会怎么选择呢?想知道!

一、冒泡排序

  第五轮比较总结:1.排序第5轮、比较1次,没有获得从小到大的排序   2.冒泡出了 2,由于还剩一个1,不用再比较了,至此通过5轮排序,完成整个排序。

冒泡排序算法 改进三

大城市随你喜好随便选,小城市从消防角度不要住太高,万一起火了活命机会大一些。

  第三轮排序:

    第二次比较  3和6比较 结果:2    3   6   1   8   9 

    第4次比较调整:97和76比较,97>76,交换位置:  38 49 65 76 97 13 27 32

    第一次比较 6和3比较 结果:3 6 8 2 9 1

  

    第1次比较调整:38和49比较,38<49,不交换位置: 38 49 65 13 27 32 76 97

    第一次比较 2和3比较 结果:2 3 1 6 8 9

   $arr 有6个数据,按照两两比较大小如下,注意  比较轮数 和 每轮比较次数 

    第4次比较调整:65和27比较,65>27,交换位置:  38 49 13 27 65 32 76 97

    第四次比较 8和9比较 结果:3 6 2 8 9 1

  算法和数据结构是一个编程工作人员的内功,技术牛不牛,一般都会看这两点。作为php程序员, 提升技能当然也得学习算法。

  共 N=8 个数据,需要 N-1=7 趟排序,第 i 趟排序共比较 N-i 次

  第四轮比较总结:1.排序第4轮、比较2次,没有获得从小到大的排序 2.冒泡出了 3,下轮不用比较3 了

    第三次比较  8和2比较 结果:3    6   2   8   9   1 

 

  第一轮排序:

 

    第5次比较调整:76和27比较,76>27,交换位置:  38 49 65 13 27 76 32 97

    第一次比较 2和1比较 结果:1 2 3 6 8 9

    第一次比较  2和3比较 结果:2    3   1   6   8   9     

 

转自:

 

冒泡排序算法——改进一

  对于一个长度为N的数组,我们需要排序 N-1 轮,每 i 轮 要比较 N-i 次。对此我们可以用双重循环语句,外层循环控制循环轮次,内层循环控制每轮的比较次数。

  

  设置标志性变量pos,用于记录每趟排序中最后一次交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

  第三轮比较总结:1.排序第3轮、比较3次,没有获得从小到大的排序 2.冒泡出了 6,下轮不用比较6 了

    第四次比较  8和1比较 结果:3    2   6   1   8   9 

  待排序数组 int a[] = {49,38,65,97,76,13,27,32};

    第三次比较 8和2比较 结果:3 6 2 8 9 1

 

图片 1

  第四轮排序:

参考链接:

    第2次比较调整:49和65比较,49<65,不交换位置: 38 49 65 76 13 27 32 97

  第五轮排序:

 

  完整代码

    第二次比较 6和3比较 结果:3 6 8 2 9 1

 

 基本思想:

    第二次比较 3和6比较 结果:2 3 6 1 8 9

  原理:对一组数据,比较相邻数据的大小,将值小数据在前面,值大的数据放在后面。   (以下都是升序排列,即从小到大排列)

冒泡排序算法——改进二

  第二轮比较总结:1.排序第2轮、比较4次,没有获得从小到大的排序 2.冒泡出了 8,下轮不用比较8 了

  通过以上五轮排序,若干次比较,我们有理由推断出一个结论:

  第二趟排序:

  通过以上五轮排序,若干次比较,我们有理由推断出一个结论:

  第一轮比较总结:1.排序第1轮、比较5次,没有获得从小到大的排序   2.因为每次比较都是大数往后靠,所以比较完成后,可以确定大数排在最后(9 已经冒泡冒出来了,下轮比较可以不用比较了 )

  加入一标志性变量exchange,用于标志某一趟排序过程中是否有数据交换。若无数据交换则说明数据已有序,可结束整个排序过程。

  原理:对一组数据,比较相邻数据的大小,将值小数据在前面,值大的数据放在后面。 (以下都是升序排列,即从小到大排列)

一、冒泡排序

  在要排序的一组数中,对当前还未排好序的范围内的全部数据,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的数往上冒。即依次比较相邻的两个数,若发现它们的排序与排序要求相反时,就将它们互。

    第四次比较 8和1比较 结果:3 2 6 1 8 9

  

    第1次比较调整:38和49比较,38<49,不交换位置: 38 49 65 76 13 27 32 97

  第五轮比较总结:1.排序第5轮、比较1次,没有获得从小到大的排序 2.冒泡出了 2,由于还剩一个1,不用再比较了,至此通过5轮排序,完成整个排序。

 

  第六趟排序:

    第二次比较 3和1比较 结果:2 1 3 6 8 9

    第一次比较  3和2比较 结果:2    3   6   1   8   9     

 Java实现:

    第一次比较 3和6比较 结果:3 6 2 8 1 9

 

(本文仅供学习交流,如有更好的思路,欢迎留下意见供大家探讨学习~)

function order($arr) {
    $count = count($arr);
    $temp = 0;
    //外层控制排序轮次
    for ($i = 0;$i < $count - 1;$i++) {
        //内层控制每轮比较次数
        for ($j = 0;$j < $count - 1 - $i;$j++) {
            if ($arr[$j] > $arr[$j + 1]) {
                $temp = $arr[$j];
                $arr[$j] = $arr[$j + 1];
                $arr[$j + 1] = $temp;
            }
        }
    }
    return $arr;
}
$arr = array(6, 3, 8, 2, 9, 1);
$res = order($arr);
var_dump($res);

  第三轮比较总结:1.排序第3轮、比较3次,没有获得从小到大的排序   2.冒泡出了 6,下轮不用比较6 了

    第3次比较调整:65和13比较,65>13,交换位置:  38 49 13 65 27 32 76 97

    第三次比较 6和8比较 结果:3 2 6 8 1 9

  第二轮排序:

package sort;
/**
 * 冒泡算法 及其 改进算法的实现
 * 稳定算法
 * @author 那一季的银杏叶
 *
 */
public class BubbleSort {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new BubbleSort().run();
    }
    public void run(){
        int a[] = {49,38,65,97,76,13,27,32};
        /**
         * 冒泡排序
         */
        bubbleSort(a);
    }
    /**
     * 冒泡算法
     */
    private void bubbleSort(int a[]){
        System.out.println("———————————————————冒泡排序算法—————————————————————");
        int n=a.length;
        for(int i=0 ; i<n-1; i++) {  
            for(int j=0; j<n-i-1; j++) {  
                if(a[j] > a[j+1]){  
                    int temp = a[j] ; a[j] = a[j+1] ;  a[j+1] = temp;  
                }  
            }
            print(a,n,i);
        } 
        printResult(a,n);
    }
    /**
     * 打印排序的最终结果
     * @param a
     * @param n
     */
    private void printResult(int[] a, int n){
        System.out.print("最终排序结果:");
     for(int j=0;j<n;j++){
            System.out.print(" "+a[j]);
        }
        System.out.println();
    }
    /**
     * 打印排序的每次循环的结果
     * @param a
     * @param n
     * @param i
     */
    private void print(int[] a, int n, int i) {
        // TODO Auto-generated method stub
        System.out.print("第"+i+"次:");
        for(int j=0;j<n;j++){
            System.out.print(" "+a[j]);
        }
        System.out.println();
    }
}

    第一次比较 3和2比较 结果:2 3 6 1 8 9

    第一次比较  3和6比较 结果:3    6   2   8   1   9     

private void bubbleSort3(int a[]){
    int n=a.length;
    int low = 0;   
    int high= n -1; //设置变量的初始值  
    int tmp,j;  
    while (low < high) {  
        for(j=low; j<high; j++) //正向冒泡,找到最大者  
            if (a[j] > a[j+1]) {  
                tmp = a[j]; a[j]=a[j+1];a[j+1]=tmp;  
            }   
        --high;//修改high值, 前移一位  

        for(j=high; j>low; j--) //反向冒泡,找到最小者  
            if (a[j]<a[j-1]) {  
                tmp = a[j]; a[j]=a[j-1];a[j-1]=tmp;  
            }  
        ++low;                  //修改low值,后移一位  
    } 
}

  举例说明: $arr = array(6, 3, 8, 2, 9, 1);

    第五次比较  9和1比较 结果:3    6   2   8   1   9 

 实例:

   $arr 有6个数据,按照两两比较大小如下,注意 比较轮数 和 每轮比较次数

    第三次比较  6和1比较 结果:2    3   1   6   8   9 

    第5次比较调整:97和13比较,97>13,交换位置:  38 49 65 76 13 97 27 32

    第五次比较 9和1比较 结果:3 6 2 8 1 9

  对于一个长度为N的数组,我们需要排序 N-1 轮,每 i 轮 要比较 N-i 次。对此我们可以用双重循环语句,外层循环控制循环轮次,内层循环控制每轮的比较次数。

 基本思想:

    第三次比较 6和1比较 结果:2 3 1 6 8 9

    第四次比较  8和9比较 结果:3    6   2   8   9   1 

 Java实现

    第二次比较 6和2比较 结果:3 2 6 8 1 9

    第二次比较  3和1比较 结果:2    1   3   6   8   9 

    第2次比较调整:49和65比较,49<65,不交换位置: 38 49 65 13 27 32 76 97

  

    第三次比较  6和8比较 结果:3    2   6   8   1   9 

冒泡排序算法 改进二

  第一轮比较总结:1.排序第1轮、比较5次,没有获得从小到大的排序 2.因为每次比较都是大数往后靠,所以比较完成后,可以确定大数排在最后(9 已经冒泡冒出来了,下轮比较可以不用比较了 )

  举例说明: $arr = array(6, 3, 8, 2, 9, 1);

    第1次比较调整:13和27比较,13<27,不交换位置: 13 27 32 38 49 65 76 97

  第二轮排序:

  下面介绍四种入门级排序算法: 冒泡排序、选择排序、插入排序、快速排序。

    第3次比较调整:38和32比较,38>32,交换位置:  13 27 32 38 49 65 76 97

  第五轮排序:

    第1次比较调整:13和27比较,13<27,不交换位置: 13 27 32 38 49 65 76 97

 

    第5次比较调整:65和32比较,65>32,交换位置:  38 49 13 27 32 65 76 97

 

    第3次比较调整:65和76比较,65<76,不交换位置: 38 49 65 76 13 27 32 97

    第二次比较  6和3比较 结果:3    6   8   2   9   1 

  核心代码

    第一次比较  6和3比较 结果:3    6   8   2   9   1     

 Java实现

    第一次比较  2和1比较 结果:1   2   3   6   8   9     

  第一趟排序:

  第四轮比较总结:1.排序第4轮、比较2次,没有获得从小到大的排序   2.冒泡出了 3,下轮不用比较3 了

  利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者), 从而使排序趟数几乎减少了一半。

 

冒泡排序算法

  第二轮比较总结:1.排序第2轮、比较4次,没有获得从小到大的排序   2.冒泡出了 8,下轮不用比较8 了

    第1次比较调整:49和38比较,49>38,交换位置:  38 49 65 97 76 13 27 32

  第一轮排序:

 

 

 Java实现

 

private void bubbleSort(int a[]){
    int n=a.length;
    for(int i=0 ; i<n-1; i++) {  
        for(int j=0; j<n-i-1; j++) {  
            if(a[j] > a[j+1]){  
                int temp = a[j] ; a[j] = a[j+1] ;  a[j+1] = temp;  
            }  
        }
    } 
}

  第四轮排序:

 

    第二次比较  6和2比较 结果:3    2   6   8   1   9 

  第七趟排序:

<?php 

  function order($arr){
      $count = count($arr);
      $temp = 0; 
      //外层控制排序轮次
      for($i=0; $i<$count-1; $i++){
          //内层控制每轮比较次数
          for($j=0; $j< $count-1-$i; $j++){
                if($arr[$j] > $arr[$j+1]){
                    $temp        = $arr[$j];
                    $arr[$j]     = $arr[$j+1];
                    $arr[$j+1]   = $temp;
               }
          }
      } 
      return $arr;
     }     


 $arr= array(6,3,8,2,9,1);
$res =  order($arr);
var_dump($res);

冒泡排序算法 改进一

  第三轮排序:

冒泡排序算法

    第2次比较调整:38和27比较,38>27,交换位置:  13 27 38 32 49 65 76 97

    第2次比较调整:49和13比较,49>13,交换位置:  38 13 49 27 32 65 76 97

 基本思想:

    第1次比较调整:38和49比较,38<49,不交换位置: 38 49 13 27 32 65 76 97

    第4次比较调整:49和32比较,49>32,交换位置:  38 13 27 32 49 65 76 97

  每趟排序都会找出一个 待排序数据 中的较大值

    第2次比较调整:49和65比较,49<65,不交换位置: 38 49 65 97 76 13 27 32

    第6次比较调整:76和32比较,76>32,交换位置:  38 49 65 13 27 32 76 97

 基本思想:

/**
 * 冒泡排序算法 改进二
 * @param a
 */
private void bubbleSort2(int a[]){
    int n=a.length;
    int i = n-1;
    while(i>0){
        /**
         * 每趟开始时,无记录交换
         */
        int pos = 0;
        for(int j=0; j<i; j++) {  
            if(a[j] > a[j+1]){  
                pos = j;
                int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;  
            }
        }
        i = pos;
    }
}

    第3次比较调整:49和27比较,49>76,不交换位置: 38 13 27 49 32 65 76 97

    第2次比较调整:27和32比较,27<32,不交换位置: 13 27 32 38 49 65 76 97

 运行结果展示:

    第1次比较调整:38和13比较,38>13,交换位置:  13 38 27 32 49 65 76 97

  第三趟排序:

冒泡排序算法——改进三

  第五趟排序:

    第6次比较调整:97和27比较,97>27,交换位置:  38 49 65 76 13 27 97 32

/**
 * 冒泡排序算法  改进 一
 */
private void bubbleSort1(int a[]){
    int n=a.length;
    boolean exchange;
    for(int i=0 ; i<n-1; i++) {  
        exchange = false;
        for(int j=0; j<n-i-1; j++) {  
            if(a[j] > a[j+1]){  
                exchange = true;
                int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;  
            }
        }
    /**
     * 如果本次循环没进行数据交换,则跳出循环
     */
        if(exchange != true) break;
    } 
}

    第7次比较调整:97和32比较,97>32,交换位置:  38 49 65 76 13 27 32 97

  第四趟排序:

    第4次比较调整:76和13比较,76>13,交换位置:  38 49 65 13 76 27 32 97

    第3次比较调整:65和97比较,65<97,不交换位置: 38 49 65 97 76 13 27 32

本文由金沙7868com发布于旅游专区,转载请注明出处:排序系列,冒泡排序

关键词:

上一篇:有没有让你忍不住想拍的视频

下一篇:没有了