数据结构与算法【插入排序法】

插入排序法(InsertionSort)

简单实现插入排序法：

• 1 ArrayGenerator .java 提供随机数据
• 2 InsertionSort 。java 插入排序算法初实现
• 3 SortingHelper .java 辅助验证 最后的数据是否为有序的 和时间性能

1 ArrayGenerator .java 提供随机数据 混乱无序的

package src;
import java.util.Random;
/**
 * @author xxz
 * @version 1.0
 * @Created on: 2024-01-21 11:10
 * @Description: 提供随机测试的数据
 */
public class ArrayGenerator {

    private ArrayGenerator(){}

    // 生成一个长度为 n 随机数组，每个数字的范围是 [0，bound)
    // 设置随机生成数组【乱序】的 generateRandomArray方法 并也返回 Integer 类型的数组 的方法供测试使用
    public static Integer[] generateRandomArray(int n, int bound) {
        Integer[] arr = new Integer[n];  // 设置随机生成的数组大小n 使用的时候去设置
        Random rnd = new Random();  // 使用Random 来生成随机的数值
        for (int i = 0; i < n; i++)
            arr[i] = rnd.nextInt(bound);  //  bound 为随机数生成的最大的那个边界在那里
        // 这一步是为数组的第i个元素赋予一个随机生成的整数值。让我解释一下：
        // `rnd.nextInt(bound)` 是使用`Random`对象（在这里是`rnd`）生成一个随机的整数值。
        // `bound` 参数指定了生成的随机数的上限，即生成的随机数将在0（包括）到`bound`（不包括）之间。
        // 将生成的随机数赋值给数组`arr`的第i个元素，即 `arr[i] = rnd.nextInt(bound);
        // 可以在数组中的每个位置都存储一个随机生成的整数，这些整数的范围在0到`bound-1`之间。
        return arr;
    }
}

2 InsertionSort.java 插入算法的实现

package src;
/**
 * @author xxz
 * @Created on: 2024-01-21 10:54
 * @version 1.0
 * @Description:  插入排序算法初实现
 */
public class InsertionSort {
    // 将空构造函数写为 private类型
    private InsertionSort(){}
    // 将 sort方法写为 泛型方法 进行泛型约束  因为插入排序是对用户传来的数组arr进行排序  而这个是泛型数组
    public static<E extends Comparable<E>> void sort(E[] arr){
        for (int i = 0; i < arr.length; i++) {
            // 将arr[i] 插入到合适的位置
            // 因为每次都要看前面一个元素所以是需要有元素的 所以 j - 1 > 0 等 价 j > 0
            for (int j = i; j - 1 >= 0; j--) {
                //每次我们查看的是当前这个arr[j] 是不是要不前面一个元素还要小 那么就要插入到前面一个元素
                if (arr[j].compareTo(arr[j - 1])< 0 )
                    // 如何插入到前面呢 使用交换元素的swap方法 交换的是 j 和 j-1 这个元素
                    swap(arr, j , j-1);
                // 否则的话要是他本身就大于  那就代表他本身就呆的位置是对的
                else break;;
            }
        }
    }
    //swap 交换元素的方法 同样是泛型方法
   public static <E> void swap(E[] arr,int i, int j){
         E t  = arr[i];
         arr[i] = arr[j];
         arr[j] = t ;
   }

   // 测试 插入排序
   public static void main(String[] args) {
        // 设置数据量 1万 和10 万
       int [] dataSize = {10000,100000};
       for (int n : dataSize){
           Integer[] arr = ArrayGenerator.generateRandomArray(n,n);
           SortingHelper.sortTest("InsertionSort",arr);
       }
    }
}

3 SortingHelper .java 辅助验证 验证是否 有序 验证算法性能时间

package src;
/**
 * @Description:  辅助验证排序
 */
public class SortingHelper {
    private SortingHelper() {}
    // 返回值为布尔值 true false  同时这个isSorted()方法 是泛型方法  这个数组也是泛型数组
    // 并且为了进行有序比较 那么这个必须是可比较的 而实现可比较 就需要有泛型约束 就得实现 Comparable 接口 重复在提
    public static <E extends Comparable<E>> boolean isSorted(E[] arr) {
        for (int i = 1; i < arr.length; i++)
            // 为什么循环从 1 开始 是因为我每次要在循环中比较的是 arr[i-1]于arr[i] 的大小关系 也就是1 和2  2和3 依次后退的关系
            // 而使用了 Comparable接口就一定会使用到 compareTo这个方法 来进行比较
            if (arr[i - 1].compareTo(arr[i]) > 0) // 此处结果要是大于0 说明使用排序算法进行排序后的数组就不是有序的 也就是说结果不对
                return false;
        return true; // 要是没有提示 false错误 那就证明我们排序后的数组是对的是有序的
    }
    public static <E extends Comparable<E>> void sortTest(String sortname,E[] arr){
        long startTime = System.nanoTime();
             // 先进行类名的判断
        if(sortname.equals("InsertionSort"))
            InsertionSort.sort(arr);
             long endTime = System.nanoTime();
             double time = (endTime - startTime ) / 1000000000.0;

        // SortingHelper 调用isSorted()来验证数组是否有序
        // 验证结果是否有效 要无效的话 我就抛出异常
        if (!SortingHelper.isSorted(arr))
            throw new RuntimeException("验证结果数组不是有序的，所以排序算法失效"+sortname+"失败");
        System.out.println(String.format("%s , n = %d : %f s", sortname + "算法进行插入排序" , arr.length , time));
    }
}

优化 插入排序法

思路： 优化的是逻辑代码

逻辑是一致的 就是写法更紧凑简单 两者都没错 看自己选择

对比插入排序和选择排序算法的测试：

先保证数据有序：

增加的有序排序方法：

package src;
import java.util.Arrays;

public class InsertionSort {
private InsertionSort(){}
public static<E extends Comparable<E>> void sort01(E[] arr){
    for (int i = 0; i < arr.length; i++) {
        for (int j = i; j - 1 >= 0  && arr[j].compareTo(arr[j - 1])< 0; j--){
            swap(arr, j , j-1);
        }
    }
}
    //swap 交换元素的方法 同样是泛型方法
   public static <E> void swap(E[] arr,int i, int j){
         E t  = arr[i];
         arr[i] = arr[j];
         arr[j] = t ;
   }

   // 测试 1 万条数据测试插入排序性能
   public static void main(String[] args) {
        // 设置数据量 1万和 10万
       int [] dataSize = {10000,100000};
       for (int n : dataSize){
           Integer[] arr = ArrayGenerator.generateRandomArray(n,n); // 用来测插入排序算法
           Integer[] arr2 = Arrays.copyOf(arr,arr.length);          // 用来测选择排序算法

           // 这是乱序的数据两者  性能
           System.out.println("Ordered Array : 无序的数据排序后的性能");
           SortingHelper.sortTest("InsertionSort",arr);
           SortingHelper.sortTest("SelectionSort",arr2);

           System.out.println();

           System.out.println("Ordered Array : 有序的数据性能");
           
           // 将数据进行排序
           arr = ArrayGenerator.generateOrderedArray(n);
           arr2 = Arrays.copyOf(arr,arr.length);
           // 这是有序的数据两者  性能
           SortingHelper.sortTest("InsertionSort",arr);
           SortingHelper.sortTest("SelectionSort",arr2);

       }
    }
}