java算法之排序算法

引文

java的排序算法，常见的主要分为选择排序、冒泡排序和插入排序

本篇对这几种排序算法的思路和代码进行分析和展示。本篇的排序演示为从小到大的排序。

1、选择排序算法

• 思路分析

第一次从待排序的数据元素中选出最小的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。 

• 代码演示

public class OrderCode {

    public static void main(String[] args) {
        int []  arry ={3,2,6,9,7,5,23,1,4,1};
        seleceSort(arry);
        for(int i=0;i<arry.length;i++){
            System.out.print(arry[i] +" ");
        }

    }

    /**
     * @Author wangchengzhi
     * @Description
     * 对集合中的数据进行从小到大的排序
     * 思路:
     * 下标为0的数据和其他数据进行比较，最小的放在下标为0的位置，不再参与比较
     * 下标为1的数据和其他数据进行比较，最小的放在下标为1的位置，不再参与比较
     * 下标为2的数据和其他数据进行比较，最小的放在下标为2的位置，不再参与比较
     * ..........
     * 以此类推，直到下标为n-1,完成所有排序
     * @Date 13:56 2022/12/14
     * @Param
     * @return
     **/
    public static void seleceSort(int[] arry){
        if(null==arry||arry.length<2){
            return ;
        }
        //获取数组的长度
        int lengh = arry.length;
        //下标从0开始，一直到下标为n-1
        for(int i=0;i<lengh;i++){
            int minIndex=i;
           //循环i后面的所数做比较
           for(int j=i+1;j<lengh;j++){
               //比较后面的数据有没有比下标为i的数据小的，有的话把该数据赋值给下标为i的位置
               minIndex = arry[j]<arry[minIndex]  ? j:minIndex;
           }
            sort(minIndex,i,arry);
        }

    }

      public  static void sort(int minIndex,int i,int[] arry){
          /**
           * 下标为i的和下标为j的数据做交换
           * 第一步:取下标最小值赋值给中间变量
           * 第二步:下标为i的和最小值下标的数据交换
           * 第三步把最小值赋值给下标为i的数
           * 数据交换结束
           * */
          int temp =arry[minIndex];
          arry[minIndex]= arry[i];
          arry[i]=temp;
      }



}

2、冒泡排序算法

• 思路分析

首先，我们比较第一对相邻的两个数字，也就是第一个数字和第二个数字，如果前一个数字大于后一个数字，就将两个数字交换；然后我们比较第二对数字，即第二个数字和第三个数字。

同理当第二个数字比第三个数字大时就交换两个数字，否则不进行操作。重复进行此操作，直到比较到第n个数字和第n-1个数字，当本步骤交换完毕后，第n个数字（即最后一个数字）就是本数列中的最大数。

当找到该数列中最大的数字后，我们就可以开始寻找第二大的数字了。步骤仍然与第一步类似，但是我们本次操作时无需再比较最后一个数字，因为它已经是最大数了。

经过第二轮的比较后，我们就找到了第二大的数字，同理我们需要进行n-1轮比较，这样我们就依次找到了第n大，第n-1大，第n-2大，以及最小的数字，将这个结果输出，我们就完成了冒泡排序。

• 代码演示

public class OrderCode{
public static void main(String[] args) {
        int []  arry ={3,2,6,9,7,5,23,1,4,1};
        bubbleSort(arry);
        for(int i=0;i<arry.length;i++){
            System.out.print(arry[i] +" ");
        }

    }

/**
     * @Author wangchengzhi
     * @Description 冒泡排序法
     * 对集合中的数据进行从小到大的排序
     * 思路:
     * 下标为0的数据开始依次和相邻的数据比较一直到第N个数，把较大的数放到最小的数后面
     * 下标为0的数据开始依次和相邻的数据比较一直到第N-1个数，把较大的数放到最小的数后面
     * 下标为0的数据开始依次和相邻的数据比较一直到第N-1个数，把较大的数放到最小的数后面
     * ..........
     * 以此类推，直到下标为0和下标为1比较,完成所有排序
     * @Date 13:57 2022/12/14
     * @Param
     * @return
     **/
    public static void bubbleSort(int [] arry){
        if(null==arry||arry.length<2){
            return ;
        }
        int length = arry.length;
        //需要循环的次数
        for(int end=length-1;end>=0;end--){
            //从0比较到N,然后比较到n-1,依次递减，交换较大的值在后面
            for(int j=1;j<=end;j++){
                if(arry[j-1]>arry[j]){
                    //如果前面的数小于后面的数就交换位置
                    sort(j-1, j,arry);
                }
            }
        }
    }

public  static void sort(int minIndex,int i,int[] arry){
          /**
           * 下标为i的和下标为j的数据做交换
           * 第一步:取下标最小值赋值给中间变量
           * 第二步:下标为i的和最小值下标的数据交换
           * 第三步把最小值赋值给下标为i的数
           * 数据交换结束
           * */
          int temp =arry[minIndex];
          arry[minIndex]= arry[i];
          arry[i]=temp;
      }




}

3、插入排序算法

• 思路分析

1. 从第一个元素开始，该元素可以认为已经被排序。
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描。
3. 如果该元素（已排序）大于新元素，则将该元素移到下一位置。
4. 重复步骤3，直到找到已排序的元素小于或者大于新元素的位置。
5. 将新元素插入到该位置。
6. 重复步骤2。 

• 代码演示 

public class OrderCode{

  public static void main(String[] args) {
        int []  arry ={3,2,6,9,7,5,23,1,4,1};
        //insertSort(arry);
        insertSort1(arry);
        for(int i=0;i<arry.length;i++){
            System.out.print(arry[i] +" ");
        }

    }


 /**
     * @Author wangchengzhi
     * @Description插入排序法
     * 从0~1范围排为有序
     * 比较0~2范围排为有序
     * 然后0~3范围排为有序
     * 依次往后，往前比较，直到所有数据都变为有序
     * @Date 19:59 2022/12/14
     * @Param
     * @return
     **/
    public static void insertSort(int[] arr){
        int length = arr.length;
        for(int end=1;end<length;end++){
            int newIndex = end;
            /*
            *while循环体 直到条件(左边已经没有需要比较的数
            * 或者相邻两个数比较已经不需要再交换排序)不成立
            * */
            while (newIndex-1>=0&&arr[newIndex-1]>arr[newIndex]){
                sort(newIndex-1,newIndex,arr);
                newIndex--;
            }

        }
    }



    /**
     * @Author wangchengzhi
     * @Description 插入排序法的优化
     * 直接循环向前交换位置
     * @Date 20:38 2022/12/14
     * @Param
     * @return
     **/
    public static void insertSort1(int[] arr){
        int length = arr.length;
        for(int end=1;end<length;end++){
            for(int pre =end-1;pre>=0&&arr[pre]>arr[pre+1];pre--){
                sort(pre,pre+1,arr);
            }

        }
    }

public  static void sort(int minIndex,int i,int[] arry){
          /**
           * 下标为i的和下标为j的数据做交换
           * 第一步:取下标最小值赋值给中间变量
           * 第二步:下标为i的和最小值下标的数据交换
           * 第三步把最小值赋值给下标为i的数
           * 数据交换结束
           * */
          int temp =arry[minIndex];
          arry[minIndex]= arry[i];
          arry[i]=temp;
      }


}

 结言：

几种算法的比较和区别：

• 复杂度

冒泡排序有两重循环，这样它的时间复杂度就是 O(n*n)；

选择排序时间复杂度：依旧是O（n*n）

插入排序时间复杂度也为O(n^2)