冒泡排序

                   /**
                   *冒泡排序算法，在一个数组中使得其按照大小顺序排序输出
                   *@author LZ
                   *@vesion 2014.6.7
                   */

                   //创建冒泡排序算法的类
                   class BubbleSort
                   {
                         //此类是一个充血模型
                          
                         /**
                         *无参的构造方法
                         *@param 无
                         *@return 无
                         */

                         public BubbleSort(){}

                         /**
                         *写一个方法BubbleSort_action()来操作排序算法
                         *@param  int[] sort
                         *@return  int[]
                         */

                         public int[] BubbleSort_action(int[] sort){

                                  //调用OutPut()，输出未经排序的元素
                                  System.out.println("未经冒泡排序的结果：");
                                  OutPut(sort);
                                  
                                  //判断传入的参数是否合法
                                  if(sort == null ||sort.length <= 0){
                                        System.out.println("参数sort或数组中无元素！");
                                  }
                                   
                                  //调用交换方法实现交换操作
                                  swap(sort);
                                
                                  //调用OutPut()，输出排序后的元素
                                  System.out.println("冒泡排序后的结果：");
                                  OutPut(sort);

                                  return sort;
                         }

                         /**
                         *写一个实现交换的代码
                         *@param int[] sort
                         *@return 无
                         */

                         public void swap(int[] sort){
                                

                                /**
                                  *算法：冒泡排序算法
                                  *int o_num 表示外层比较所处的次数
                                  *int i_num 表示内层仍需比较所处的次数
                                  */

                                  int o_num =0;
                                  int i_num =0;
                                  //定义一个整型的变量来短暂的存储交换时候的值
                                  int temp = 0;
                                  
    
                              outer:
                                  for(o_num = 0;o_num < sort.length-1 ;o_num++){

                                          //内层循环
                                    inner:
                                         for(i_num = 0;i_num <sort.length-o_num-1;i_num++){
                                              
                                              //冒泡排序，轻的冒起来
                                              if(sort[i_num] > sort[i_num+1]){
                                                  //实现交换的代码
                                                    temp = sort[i_num];
                                                    sort[i_num] = sort[i_num +1];
                                                    sort[i_num+1] = temp;
                                                     
                                              }
 
                                         }

                                  }
                                 /** System.out.println(">>>>>>>>");
                                  *for(int i = 0;i < 9 ;i++){
                                  *   System.out.println(sort[i]);
                                  *
                                  *}
                                  *System.out.println("i_num="+i_num+"o_num="+o_num+"length = "+sort.length);
                                  */
                                  if(o_num == sort.length){System.out.println("冒泡成功！");}
                         }

                         /**
                         *写一个方法OutPut()输出排序前后的元素
                         *@param int[] sort
                         *@return 无
                         */

                         public void OutPut(int[] sort){
                             //定义一个整型变量记录输出位置
                             int i ;
                             //输出数组中保存的元素
                             for(i = 0;i <sort.length ;i++){

                                    System.out.println(sort[i]+" ");
                             
                             }
                             System.out.println("元素个数为："+sort.length);
                              
                         }
                   }