初识Java（Java数组-数组排序算法)

最新推荐文章于 2023-07-25 13:48:28 发布

原创最新推荐文章于 2023-07-25 13:48:28 发布 · 285 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#Java基础

Java 专栏收录该内容

45 篇文章

订阅专栏

本文介绍了三种常见的数组排序算法：冒泡排序、直接选择排序和反转排序。详细解释了每种算法的基本思想、算法示例及其实现过程。

一、数组排序算法

1.1 冒泡排序

在程序设计中，经常需要将一组数列进行排序，这样更加方便统计与查询。

冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是将小数往前放、大数往后放，类似水中气泡往上升的动作，所以称作冒泡排序。

（ 1 ）基本思想

冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动数组前面，把大的元素移动数组后面（也就是两个元素交换位置），这样较小的元素就想气泡一样从底部上升到顶部。

（ 2 ）算法示例

冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，一般为要排序的数组长度减 1 次，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序。而内层循环主要用于对比数组中每个临近元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。

（ 3 ）算法实现

eg ：实现冒泡排序，正排序。

public class BubbleSort{
    public static void main(String[] args){
        int[] array = { 63, 4, 24, 1, 3, 15 };         //创建一个数组，这个数组元素是乱序
        BubbleSort sorter = new BubbleSort();          //创建冒泡排序类的对象
        sorter.sort(array);                            //调用排序方法将数组排序
    }
    /**
     * 冒泡排序
     *@param array 要排序的数组
     */
    public void sort(int[] array){
        for(int i = 0 ; i < array.length ; i++){
            //比较相邻两个元素，较大的数往后冒泡
            for(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);                                   //输出冒泡排序后的数组元素
    }
    /**
     * 显示数组中的所有元素
     *@param array 要显示的数组
     */
    public void showArray(int[] array){
        for(int i : arrray){                            //遍历数组
            System.out.print(">"+i);                    //输出每个数组元素值
        }
        System.out.println();
    }
}

运行结果为：> 1 > 3 > 4 > 15 > 24 > 63

冒泡排序的主要思想是：把相邻两个元素进行比较，如满足一定条件则进行交换（如判断大小或日期前后等），每次循环都将最大（或最小）的元素排在最后，下一次循环是对数组中其他的元素进行类似操作。

1.2 直接选择排序

直接选择排序方法是属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法。

（ 1 ）基本思想

直接选择排序的基本思想是将排序位置与其他数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的格式。

与冒泡排序相比，直接选择排序的交换次数要少很多，所以速度更快些。

（ 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 };             //创建一个数组
        SelectSort sorter = new SelectSort();              //创建直接选择排序类的对象
        sorter.sort(array);                                //调用排序对象的方法将数组排序
    }     
    /**
    * 直接选择排序法
    * @param array 要排序的数组
    */
    public void sort(int[] array){
        int index ;
        for(int i = 1 ; i < array.length ; i++){
            index = 0;
            for(int j = 1 ;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);                                  //输出直接选择排序后的数组值
    }
    /**
    * 显示数组中的所有元素
    * @param array 要显示的数组
    */
    public void showArray(int[] array){
        for(int i : array){                                //遍历数组
            System.out.print(">"+i);                       //输出每个数组元素值
        }
        System.out.println();
    }
}

运行结果为： > 1 > 3 > 4 > 15 > 24 > 63

1.3 反转排序

反转排序就是以相反的顺序把原有数组的内容重新排序。反转排序算法在程序开发中也经常用到。

（ 1 ）基本思想

就是把数组最后一个元素与第一个元素替换，倒数第二个与第二个元素替换，以此类推，直到所有数组元素反转替换。

（ 2 ）算法示例

反转排序是对数组两边的元素进行替换，所以只需要循环数组长度的半数次，如数组长度为 7 ，那么 for 循环只需要循环 3 次。

eg ：

初始数组资源 [ 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};             //创建一个数组
        ReverseSort sorter = new ReverseSort();            //创建反转排序类的对象
        sorter.sort(array);                                //调用排序对象的方法将数组反转
    }
    /**
    *直接选择排序法
    *@param array 要排序的数组
    */
    public 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];
            arrray[i] = array[len-1-i];
            array[len-1-i] = temp;
        }
        System.out.println("数组反转后的内容:");
        showArray(array);                                  //输出排序后的数组值
   }
    /**
     *显示数组中的所有元素
    *@param array 要显示的数组
    */
    public void showArray(int[] array){
        for(int i : array){                                //遍历数组
            System.out.printl("\t"+i);                     //输出每个数组元素值
        }  
    System.out.println();
    }
}

运行结果为：

数组原有内容： 10 20 30 40 50 60

数组反转后的内容： 60 50 40 30 20 10