JAVA开发之 40-JAVA数组知识点（三）

五.数组排序算法
数组有很多处常用的算法，本节将介绍常用的排序算法，包括冒泡排序法、直接选择排序法和反转排序。
1.冒泡排序
在程序设计中，经常需要将一组数列进行排序，这样更加方便统计与查询。程序常用的排序方法有：冒泡排序、选择排序和快速排序等。这次我们介绍冒泡排序法，它以简洁的思想与实现方式而备受青睐。
冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是将小数往前放、大数往后放，类似于水中气泡往上升的动作，所以称做冒泡排序 。
1）基本思想
冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（也就是交换 两个元素的位置），这样较小的元素就像是气泡一样从底部上升到顶部。
2）算法示例
冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，一般为要排序的数组长度减1次，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序了。而内层循环主要用于对比数组中每个邻近元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少，例如，一个拥有6个元素的数组，在排序过程中每一次循环的排序过程和结果如下图所示：

第一轮外层循环时把最大的元素63移动到了最后面（相应地，比63小的元素向前移动，类似气泡上升），第二轮外层循环不再对比最后一个元素值63，因为它已经被确认为最大（不需要上升），应该放在最后，需要对比和移动的是其他剩余元素，这次将元素24移动到63的前一个位置，其他循环将以此类推，继续完成排序任务。
3）算法实现
下面来介绍一下冒泡排序的具体用法。
例如：
在项目中创建类，这个类的代码将实现冒泡排序的一个演示，其中排序使用是正序。

public class BubbleSort{
    public static void main(String[] args){ 
       //创建一个数组，这个数组元素是乱序的
        int[] array = {63,4,24,1,3,15}; 
        //创建冒泡排序类的对象
        BubberSort sorter = new BubberSort(); 
        //调用排序方法将数组排序
        sorter.sort(array); 
    }
    //冒泡排序
    public static sort (int[] array){
        for(int i=1; i<array.length; i++){
            for (int j =0;j <array.length -i; j++){
              if(array[j]>array[j+1]){
                    int temp = array[j]; 
                    array[j]=array[j+1];
                    array[j+1]=temp;
                            }           
                    }
            }
       showArray(array);
   }
   //显示数组中的所有元素
    public void showArray(int[] array){
        for(int i :array){
             System.out.print(">"+i);
           }
      System.out.println();
     }
}

说明一下：
可能是自己太笨了，这段代码我死活也执行不出来，那个BubbleSort自己也没有看懂，后来就把代码简单改了改，改成了下面那样:

public class BubbleSort{  //创建类
    public static void main(String[] args){//主方法
        int[] array =  {63,4,24,1,3,15}; //定义无序数组
        sort(array); //调用sort方法对数组进行排序
    }
    //sort方法，对数组进行排序
    public static void sort (int[] array){
        for(int i=1; i<array.length; i++){
            for (int j =0;j <array.length -i; j++){
              if(array[j]>array[j+1]){
                    int temp = array[j]; 
                    array[j]=array[j+1];
                    array[j+1]=temp;    
                    }           
                }
            }
     showArray(array);//调用showArra方法输出冒泡排序后的数组
   }
   //showArray方法
    public static void showArray(int[] array){
        for(int i:array){ //遍历数组
             System.out.print(">"+i);
           }
          System.out.println();
     }
}

输出结果：

1>3>4>15>24>63
从实例的运行结果来看，数组中元素已经按从小到大的顺序排列好了。冒泡排序的主要思想就是：把相邻两个元素进行比较，如满足一定条件则进行交换（如判断大小或日期前后等），每次循环都将最大（或最小）的元素排在最后，下一次循环是对数组中其他的元素进行类似操作。

---

2.直接选择排序
直接选择排序方法属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法 。
1）基本思想
直接选择排序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻数组，而是把满足条件的元素与指定的排序位置交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，最后整个数组都成为已排好序的格式。
好比有一个小学生，从包含数字1-10的乱序的数字堆中分别选择合适的数字，组成一个1-10的排序，这个学生首先从数字堆中选出1，放在第一位，然后选出2（注意这时数字堆中已经没有1了），放在第二位，依此类推，直到其找到数字9，放到8的后面，最后剩下10，就不用选择了，直接放到最后就可以了。
与冒泡排序相比，直接选择排序的交换次数要少很多，所以速度会快些。
2）算法示例
每一趟从待排序的数组元素中选出最小（或最大）的一个元素，顺序的放在已排好序的数列最后，直到全部待排序的数据元素排完。
例如：
初始数据资源 【63 4 24 1 3 15】
第一趟排序后 【15 4 24 1 3 】63
第二趟排序后 【15 4 3 1 】24 63
第三趟排序后 【1 4 3 】15 24 63
第四趟排序后 【1 3 】4 15 24 63
第五趟排序后 【1】3 4 15 24 63
3）算法实现
下面来介绍一下直接选择排序的具体用法。
例如：
在项目中创建类，这个类的代码将作为直接选择排序的一个演示，其中排序使用的是正排序。

public class SelectSort{
    public static void main(String[] args){
            int[] array = {63,4,24,1,3,15}; 
            sort(array); 
        }
//sort方法，用于对数组进行排序
 public static void sort(int[] array ){
        int index; 
        for(int i = 1; i<array.length;i++){
            index = 0 ; 
            for(int j = 0 ;j <=array.length-i; j++){
                if(array[j]>array[index]){
                    index = j; 
                  }
             }
         //交换在位置array.length-i和index(最大值)上的两个数
             int temp=array[array.length-i];
             array[array.length-i]=array[index];
             array[index]=temp; 
        }
         showArray(array);
}
//showArray方法，用于显示出数组中每个元素的值
 public static void showArray(int[] array){
    for(int i :array){
        System.out.print(">"+i);
      }
    System.out.println();
     }
}

输出结果：

1>3>4>15>24>63

---

3.反转排序
顾名思义，反转排序就是以相反的顺序把原有数组的内容重新排序，反转排序算法在程序开发中也经常用到。
1）基本思想
反转排序的基本思想比较简单，也很好理解，其实现思路就是把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，依此类推，直到把所有的数组元素反转替换。
2）算法示例
反转排序是对数组两边的元素进行替换，所以只需要循环数组长度的半数次，如数组的长度为7，那么for循环只需要循环3次。
例如：
初始数组资源【10 20 30 40 50 60】
第一趟排序后 60 【20 30 40 50】10
第二趟排序后 60 50 【30 40 】20 10
第三趟排序后 60 50 40 30 20 10
3）算法实现
下面来介绍一下反转排序的具体用法。
例如：
在项目中创建类，这个类的代码将作为反转排序的一个演示。

public class ReverseSort{
    public static void main(String[] args){
         int[] array = {10,20,30,40, 50 ,60}; 
         sort(array);   
     }
 public static void sort(int[] array){
        System.out.println("数组原有内容：");
        showArray(array); //调用方法

        int temp; 
        int len = array.length; //获取数组长度
        //完成数组元素的反转
        for(int i =0;i<len/2; i++){
                temp= array[i]; 
                array[i]=array[len-1-i];
                arr[len-1-i]= temp; 
            } 
            System.out.println("数组反转后的内容：");
            showArray(array);
          }
      //输出数组各元素的值
    public static void showArray(int[] array){
        for(int i :array){
            System.out.print("\t"+i); 
        }
           System.out.println();
    }
}

输出结果：
数组原有内容：
10 20 30 40 50 60
数组反转后的内容：
60 50 40 30 20 10

---