基本排序算法(冒泡,选择,插入)

三大基本排序(冒泡,选择,插入)

前言

• 本人小白一枚,往后定期更新,还请各位大佬多多指教.所提交代码,均是本人亲测.
• 所写类在文章的最后
• 方法elapsedTime()是单元测试Junit方法,使用方法注解已标明

方法介绍

1. //每次调用该方法,都会获得长度为10的数组,数组每个元素是1-100的随机元素
       public int[] autoArray() {
           int[] arr = new int[10];
           for (int i = 0; i < arr.length; i++) {
               //(int) Math.random() 取值范围: [0,1); 并将随机数赋值给对应的索引位置
               arr[i] = (int) (Math.random() * 100 + 1);
           }
           System.out.println("当前自动生成的数组==>" + Arrays.toString(arr) + "\n");
           return arr;
       }
   

2. /***
    * 两个数组元素互换值
    * 运用知识 " ^ "
    * @param a 数组 arr 的一个索引值
    * @param b 数组 arr 的一个索引值
    * @param arr 数组
    */
   public void swap(int a,int b,int[]arr){
       arr[a] = arr[a] ^ arr[b];
       arr[b] = arr[a] ^ arr[b];
       arr[a] = arr[a] ^ arr[b];
   }
   

3.     /***
        * 计算执行方法所运行的时间
        * 单元测试Junit方法
        * 使用要求：方法上加上注解 @Test 该方法要被 public修饰 无返回值 无参
        * 测试使用：选中方法名 -- 右键 -- run as
        */
       @Test
       public void elapsedTime(){
           //获取当前时间,虽然返回值的时间单位为毫秒，但该值的粒度取决于底层操作系统，并且可能较大.
           long start = System.currentTimeMillis();
           //冒泡排序
   //        bubbleSort();
           //选择排序
   //        selectionSort();
           //插入排序
           insertSort();
           long end = System.currentTimeMillis();
           System.out.println("当前方法执行所花费时间==>" + (end - start) + "毫秒");
       }
   

4. /***
    * 冒泡排序
    */
   public void bubbleSort(){
   
       //获得长度为10的数组,数组每个元素是1-100的随机元素
       int[] arr = autoArray();
       //每当一次外循环结束 都能确定一个值(最大值)
       for (int i = arr.length - 1; i > 0; i--) {
           System.out.println("开始内循环");
           for (int j = 0; j < i; j++) {
               if(arr[j]>arr[j + 1]){
                   //两个数组元素互换值
                   swap(j,j+1,arr);
                   System.out.println("互换后的数组==>" + Arrays.toString(arr));
               }
           }
           System.out.println("本次内循环结束" + "\n");
       }
   }
   

5. /***
    * 选择排序
    */
   public void selectionSort(){
   
       //获得长度为10的数组,数组每个元素是1-100的随机元素
       int[] arr = autoArray();
       //int[] arr = {45, 19, 49, 3, 20, 3, 54, 48, 17, 24};
       for (int i = 0; i < arr.length; i++) {
           System.out.println("内循环 i 索引==>" + i);
           int numIndex = i;
           /***
            * 每次内循环结束都能从左边开始确定一个数
            * 例:第一次确定最小的数,索引值为 0
            */
           for (int j = i + 1; j < arr.length; j++) {
               //减少时间复杂度 避免有两个随机数是相等的情况
               if (arr[j] < arr[i] && arr[i] != arr[j]) {
                   numIndex = j;
                   swap(i, numIndex, arr);
                   System.out.println("互换后的数组==>" + Arrays.toString(arr));
               }
           }
           System.out.println("本次内循环结束" + "\n");
       }
   }
   

6. /***
        * 插入排序
        */
       public void insertSort(){
           //获得长度为10的数组,数组每个元素是1-100的随机元素
           int[] arr = autoArray();
   //        int[] arr = {12, 4, 40, 16, 12, 96, 33, 3, 58, 1};
           for (int i = 1; i < arr.length; i++) {
               System.out.println("内循环 i 索引==>" + i);
               /***
                * 当 arr[i]比 arr[i - 1]的值小,进入处理
                * 外循环次数越多 数组的排序越明显
                */
               if (arr[i] < arr[i - 1]) {
                   // 临时变量 num 存储 arr[i]的值
                   int num = arr[i];
                   // 从当前位置开始处理
                   int j = i;
                   // 将比 num 大的数往后挪一个位置，为 num 腾出一个合适位置
                   while (j > 0 && num < arr[j - 1]) {
                       arr[j] = arr[j - 1];
                       System.out.println("while循环填充后的数组==>" + Arrays.toString(arr));
                       // 填充完后, 继续向前比较,直到遇到前面一值arr[j-i]比arr[j]小 break;
                       j--;
                   }
                   // 将 num 放在属于它的位置上
                   arr[j] = num;
               }
               System.out.println("本次外循环结束的数组==>" + Arrays.toString(arr) + "\n");
           }
           System.out.println("最后后的数组==>" + Arrays.toString(arr));
       }
   

所写类

package csdn.algorithm;

import org.junit.Test;

import java.util.Arrays;

/**
 * Author:BetterFlyFish
 * Date: 2021/4/24 16:04
 * Version: 1.0
 * Description: 基本排序
 * 冒泡排序
 * 选择排序
 * 插入排序
 */
public class algorithm {
    //每次调用该方法,都会获得长度为10的数组,数组每个元素是1-100的随机元素
    public int[] autoArray() {
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            //(int) Math.random() 取值范围: [0,1); 并将随机数赋值给对应的索引位置
            arr[i] = (int) (Math.random() * 100 + 1);
        }
        System.out.println("当前自动生成的数组==>" + Arrays.toString(arr) + "\n");
        return arr;
    }

    /***
     * 两个数组元素互换值
     * 运用知识 " ^ "
     * @param a 数组 arr 的一个索引值
     * @param b 数组 arr 的一个索引值
     * @param arr 数组
     */
    public void swap(int a,int b,int[]arr){
        arr[a] = arr[a] ^ arr[b];
        arr[b] = arr[a] ^ arr[b];
        arr[a] = arr[a] ^ arr[b];
    }

    /***
     * 计算执行方法所运行的时间
     * 单元测试Junit方法
     * 使用要求：方法上加上注解 @Test 该方法要被 public修饰 无返回值 无参
     * 测试使用：选中方法名 -- 右键 -- run as
     */
    @Test
    public void elapsedTime(){
        //获取当前时间,虽然返回值的时间单位为毫秒，但该值的粒度取决于底层操作系统，并且可能较大.
        long start = System.currentTimeMillis();
        //冒泡排序
//        bubbleSort();
        //选择排序
//        selectionSort();
        //插入排序
        insertSort();
        long end = System.currentTimeMillis();
        System.out.println("当前方法执行所花费时间==>" + (end - start) + "毫秒");
    }

    /***
     * 冒泡排序
     */
    public void bubbleSort(){

        //获得长度为10的数组,数组每个元素是1-100的随机元素
        int[] arr = autoArray();
        //每当一次外循环结束 都能确定一个值(最大值)
        for (int i = arr.length - 1; i > 0; i--) {
            System.out.println("开始内循环");
            for (int j = 0; j < i; j++) {
                if(arr[j]>arr[j + 1]){
                    //两个数组元素互换值
                    swap(j,j+1,arr);
                    System.out.println("互换后的数组==>" + Arrays.toString(arr));
                }
            }
            System.out.println("本次内循环结束" + "\n");
        }
    }

    /***
     * 选择排序
     */
    public void selectionSort(){

        //获得长度为10的数组,数组每个元素是1-100的随机元素
        int[] arr = autoArray();
        //int[] arr = {45, 19, 49, 3, 20, 3, 54, 48, 17, 24};
        for (int i = 0; i < arr.length; i++) {
            System.out.println("内循环 i 索引==>" + i);
            int numIndex = i;
            /***
             * 每次内循环结束都能从左边开始确定一个数
             * 例:第一次确定最小的数,索引值为 0
             */
            for (int j = i + 1; j < arr.length; j++) {
                //减少时间复杂度 避免有两个随机数是相等的情况
                if (arr[j] < arr[i] && arr[i] != arr[j]) {
                    numIndex = j;
                    swap(i, numIndex, arr);
                    System.out.println("互换后的数组==>" + Arrays.toString(arr));
                }
            }
            System.out.println("本次内循环结束" + "\n");
        }
    }

    /***
     * 插入排序
     */
    public void insertSort(){
        //获得长度为10的数组,数组每个元素是1-100的随机元素
        int[] arr = autoArray();
//        int[] arr = {12, 4, 40, 16, 12, 96, 33, 3, 58, 1};
        for (int i = 1; i < arr.length; i++) {
            System.out.println("内循环 i 索引==>" + i);
            /***
             * 当 arr[i]比 arr[i - 1]的值小,进入处理
             * 外循环次数越多 数组的排序越明显
             */
            if (arr[i] < arr[i - 1]) {
                // 临时变量 num 存储 arr[i]的值
                int num = arr[i];
                // 从当前位置开始处理
                int j = i;
                // 将比 num 大的数往后挪一个位置，为 num 腾出一个合适位置
                while (j > 0 && num < arr[j - 1]) {
                    arr[j] = arr[j - 1];
                    System.out.println("while循环填充后的数组==>" + Arrays.toString(arr));
                    // 填充完后, 继续向前比较,直到遇到前面一值arr[j - i]比arr[j]小 break;
                    j--;
                }
                // 将 num 放在属于它的位置上
                arr[j] = num;
            }
            System.out.println("本次外循环结束的数组==>" + Arrays.toString(arr) + "\n");
        }
        System.out.println("最后后的数组==>" + Arrays.toString(arr));
    }

}