数据结构插入排序

最新推荐文章于 2020-09-07 18:24:04 发布

warrah

最新推荐文章于 2020-09-07 18:24:04 发布

阅读量554

点赞数 1

分类专栏：岁月云——java基础文章标签：插入排序数据结构 java

本文链接：https://blog.csdn.net/warrah/article/details/52263857

版权

岁月云——java基础专栏收录该内容

52 篇文章 0 订阅

订阅专栏

插入排序应该是最简单的排序方法，思考方式是这样的：有一堆数，左边的数，右边的数据。左边里面的数是已经排好序的，而右边是待排序的数据。那么接下来要处理的问题，怎么样让左边的数是排好序的。
这个策略也比较简单，降序的排列策略如下：
从位置0开始，将位置1的数据和他比较，如果位置1的数据比0大，则将位置1的数据插入到位置0前面，此刻0、1位置的顺序就排好了，
接下来，将位置2的数据，从右向左查找比位置2大的数据，也就是从位置1向位置0方向找，为什么？因为位置1的数据结果第一轮排序，已经排到0的后面了。
其他以此类推，始终保持左边是排好序的数据目的就达到了。

 /**
     * 插入排序
     * @param datas 待排序的数据
     * @param asc true：升序，false：降序
     */
    public static  <T extends Comparable<? super T>> void insertionSort(T[] datas, boolean asc){
        int j;
        print(datas);
        for (int p=1; p<datas.length; p ++){
            T tmp = datas[p];
            for ( j=p; j>0 && compare(tmp, datas[j-1], asc); j--){

                datas[j] = datas[j-1];
            }
            datas[j] = tmp;
            //
            print(datas);
        }
        print(datas);
    }

/**
     * 根据升序、降序，比较
     * @param tmp
     * @param data
     * @param asc
     * @return
     */
    private static <T extends Comparable<? super T>> boolean compare(T tmp, T data, boolean asc){
        return asc?tmp.compareTo(data)<0:tmp.compareTo(data)>0;
    }

    /**
     * 打印
     * @param datas
     */
    private static <T extends Comparable<? super T>> void print(T[] datas){
        for (T data:datas){
            System.out.print(data + " ");
        }
        System.out.println();
    }

单元测试

/**
     * 插入排序
     */
    @Test
    public void insertion_sort_test(){
        Integer[] datas = {81,94,11,96,12,35,17,95,28,58,41,75,15};
        SortUtil.insertionSort(datas,false);// 降序
        System.out.println("-------------------------------");
        SortUtil.insertionSort(datas,true);// 升序
    }

执行结果

81 94 11 96 12 35 17 95 28 58 41 75 15 原始数据
94 81 11 96 12 35 17 95 28 58 41 75 15 81向左找比他大的数据，没有即停止
94 81 11 96 12 35 17 95 28 58 41 75 15 11向左找比他大的数据，没有即停止
96 94 81 11 12 35 17 95 28 58 41 75 15 96向左找比他大的数据，找到则替换位置
96 94 81 12 11 35 17 95 28 58 41 75 15 剩下的以此类推
96 94 81 35 12 11 17 95 28 58 41 75 15 
96 94 81 35 17 12 11 95 28 58 41 75 15 
96 95 94 81 35 17 12 11 28 58 41 75 15 
96 95 94 81 35 28 17 12 11 58 41 75 15 
96 95 94 81 58 35 28 17 12 11 41 75 15 
96 95 94 81 58 41 35 28 17 12 11 75 15 
96 95 94 81 75 58 41 35 28 17 12 11 15 
96 95 94 81 75 58 41 35 28 17 15 12 11 
96 95 94 81 75 58 41 35 28 17 15 12 11 
-------------------------------
96 95 94 81 75 58 41 35 28 17 15 12 11 
95 96 94 81 75 58 41 35 28 17 15 12 11 
94 95 96 81 75 58 41 35 28 17 15 12 11 
81 94 95 96 75 58 41 35 28 17 15 12 11 
75 81 94 95 96 58 41 35 28 17 15 12 11 
58 75 81 94 95 96 41 35 28 17 15 12 11 
41 58 75 81 94 95 96 35 28 17 15 12 11 
35 41 58 75 81 94 95 96 28 17 15 12 11 
28 35 41 58 75 81 94 95 96 17 15 12 11 
17 28 35 41 58 75 81 94 95 96 15 12 11 
15 17 28 35 41 58 75 81 94 95 96 12 11 
12 15 17 28 35 41 58 75 81 94 95 96 11 
11 12 15 17 28 35 41 58 75 81 94 95 96 
11 12 15 17 28 35 41 58 75 81 94 95 96