冒泡算法

马上就要秋季校园招聘了，这段时间复习下算法吧，感觉一直都在做项目的话，其实很多时候没有真正去理解一些东西，只是实战经验比较充足，先来说一下冒泡算法吧，整个过程网上都有，在网上找了一个说的比较详细和简单的过程，大致如下：

第一趟排序(外循环)

第一次两两比较6 > 2交换(内循环)

交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |

 

第二次两两比较,6 > 4交换

交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 6 | 1 | 5 | 9 |

 

第三次两两比较,6 > 1交换

交换前状态| 2 | 4 | 6 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 6 | 5 | 9 |

 

第四次两两比较,6 > 5交换

交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

 

第五次两两比较,6 < 9不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

 

第二趟排序(外循环)

第一次两两比较2 < 4不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

 

第二次两两比较,4 > 1交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 | 
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

 

第三次两两比较,4 < 5不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 | 
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

 

第四次两两比较,5 < 6不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

 

第三趟排序(外循环)

第一次两两比较2 > 1交换

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

 

第二次两两比较,2 < 4不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

 

第三次两两比较,4 < 5不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

 

第四趟排序(外循环)无交换

第五趟排序(外循环)无交换

排序完毕,输出最终结果1 2 4 5 6 9

看完上面的大致应该了解了冒泡的原理了吧，剩下的我就贴些代码，毕竟这个东西比较多，我就不做太多的解释了

package com.demo;




import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;


/**
 * Created by wk on 2014/6/26.
 */
public class BubbleSort {
    //冒泡算法
    public static void main(String args[]) {
        int[] older_arr = getArray(10);
        System.out.println("未排序：");
        display(older_arr);
        int[] new_arr = bubbleSort(older_arr);
        System.out.println("排序后：");
        display(new_arr);
    }


    public static void display(int[] arrays) {
        for (Integer i : arrays)
            System.out.print(i + ",");
    }


    //获取不重复随机数
    public static int[] getArray(int n) {
        List<Integer> list = new ArrayList<Integer>();
        int[] ins = new int[n];


        for (int i = 0; i < n; i++) {
            int number = new Random().nextInt(1000);
            if (!list.contains(number)) {
                list.add(number);
                ins[i] = number;


            }




        }




        return ins;
    }


    public static int[] bubbleSort(int[] sorts) {
        int length = sorts.length;
        for (int i = 0; i < length; i++) {
            boolean changed = false;//做一个标志位进行优化处理
            for (int j = 0; j < length-i-1; j++) {
                if (sorts[j] > sorts[j+1]) {
                    int tmp = sorts[j+1];
                    sorts[j+1] = sorts[j];
                    sorts[j] = tmp;
                    changed = true;
                }
            }
            if (!changed)
                break;


        }
        return sorts;
    }
}

这就是一个大概的过程，在冒泡算法那里加了一个标志位，标志当算法已经排序完成之后，其实就没有必要在进行对排序好的数据进行遍历了，对于这个标注位来说，有两种极端情况，一种是都排序到最后一趟，要遍历完所有数据之后才结束，当然这个时候的标志位可能就要使速率下降了，但如果这个数据是已经排序好的，这个时候就不需要对数据进行两次遍历了和排序了