选择排序

//选择排序

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

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

                         public ChooseSort(){}

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

                         public void ChooseSort_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);
                         }

                         /**
                         *写一个实现交换的代码
                         *@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 = o_num;i_num < sort.length -1;i_num++){
                                           //让最小的总是处在最前面
                                            //选择排序的核心代码

                                              if(sort[o_num] > sort[i_num+1]){
                                                    temp = sort[o_num];
                                                  sort[o_num] = sort[i_num+1];
                                                  sort[i_num+1] = temp;

                                              }
                                        }
                                        

                                  }
                                 
                                  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);
                              
                         }
                   }

//只是记录个人的学习过程。