排序算法-插入排序

已于 2023-04-26 14:38:58 修改
阅读量311 收藏
点赞数
分类专栏： 算法 文章标签： 排序算法 算法
于 2022-11-01 15:05:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44715376/article/details/127633932
版权

插入排序

什么是插入排序

插入排序（Insertion sort），也被称为直接插入排序。

对少量的元素进行排序，效果很显著。

生活中，玩扑克牌就是利用了插入排序。拿到一张牌后，插入到手里的有序排列中，直到将牌拿完并排序结束
在这里插入图片描述

数组也是一样，要排序的元素按照大小依次插入到已经排好的有序数组中，直到排完为止

原理

  • 插入排序的基本思想是将待排序的数组分成两部分，已排序的和未排序的。

  • 每次从未排序的部分中取出第一个元素，将它插入到已排序的部分中的合适位置。插入时，从已排序的部分的最后一个元素开始比较，如果比它大，则将它后移一位，直到找到合适的位置。具体实现是通过嵌套两个循环，外层循环控制待排序的元素，内层循环控制已排序的元素。在内层循环中，如果当前元素比前一个元素小，则将前一个元素后移一位，直到找到合适的位置，然后将当前元素插入到该位置。

升序插入排列

 @Test
    public void testInsertAscengSort() {
        int[] a = {5, 3, 8, 1, 9, 23, 11, 6};
        int aLength = a.length;
        System.out.println("排序前"+Arrays.toString(a));
        //第一轮排序
        for (int i = 1; i < aLength; i++) {
            //将当前元素赋值给变量
            int insertData = a[i];
            while (i > 0) {
                //两个相邻的元素做比较
                if (a[i - 1] > insertData) {
                    //将大的值往后一个位置移
                    a[i] = a[i - 1];
                } else if (a[i - 1] < insertData) { // 如果小于insertData，插入位置

                    a[i] = insertData;
                    break;
                }
                /**
                 * 索引递减
                 * while循环反复进行元素比较
                 */
                i--;
            }
            //如果是第一个位置就将其插入
            if (i == 0) {
                a[0] = insertData;
            }
        }
        System.out.println(Arrays.toString(a));
    }

测试结果

在这里插入图片描述

方式2

@Test
public void test() {
    int[] a = {5, 3, 8, 1, 9, 23, 11, 6};
    // 从第二个元素开始，依次将买个元素插入到前面已排序的序列中
    for (int i = 1; i < a.length; i++) {
        int j = i;
        int temp = a[j];
        //while循环检测当前元素temp是否小于其左侧的元素a[j - 1]
        while (j > 0 && a[j - 1] > temp){
            //调换位置
            a[j] = a[j - 1];
            /**
             * 用于每次while循环迭代后将j的值减1（必须）
             * 因为while循环用于向右侧移动元素，直到找到当前元素的正确位置，通过减小j，
             * 确保当前元素被插入到已排序的字数组中的正确位置
             */
            j--;
        }
        a[j] = temp;
    }
    System.out.println(Arrays.toString(a));

}

在这里插入图片描述

降序插入排序

@Test
public void testInsertAscengSort() {
    int[] a = {5, 3, 8, 1, 9, 23, 11, 6};
    int aLength = a.length;
    System.out.println("排序前"+Arrays.toString(a));
    //第一轮排序
    for (int i = 1; i < aLength; i++) {
        //将当前元素赋值给变量
        int insertData = a[i];
        while (i > 0) {
            //两个相邻的元素做比较
            if (a[i - 1] < insertData) {
                //将小的值往后一个位置移
                a[i] = a[i - 1];
            } else if (a[i - 1] > insertData) { // 如果大于insertData，插入位置

                a[i] = insertData;
                break;
            }
            /**
             * 索引递减
             * while循环反复进行元素比较
             */
            i--;
        }
        //如果是第一个位置就将其插入
        if (i == 0) {
            a[0] = insertData;
        }
    }
    System.out.println("排序后"+Arrays.toString(a));
}

测试结果

在这里插入图片描述

插入排序工具类

package com.sin.demo.utli;


/**
 * @author sin
 * @date 2022/11/1
 * @apiNote
 */
public class InsertSortUtils {

    /**
     * 升序排序
     *
     * @param array
     * @return
     */
    public byte[] ascengSort(byte[] array) {
        int arrayLength = array.length;

        for (int i = 1; i < arrayLength; i++) {
            byte insertData = array[i];
            while (i > 0) {
                if (array[i - 1] > insertData) {
                    array[i] = array[i - 1];
                } else if (array[i - 1] < insertData) {
                    array[i] = insertData;
                    break;
                }
                i--;
            }
            if (i == 0) {
                array[0] = insertData;
            }
        }
        return array;
    }
    /**
     * 升序排序
     *
     * @param array
     * @return
     */
    public short[] ascengSort(short[] array) {
        int arrayLength = array.length;

        for (int i = 1; i < arrayLength; i++) {
            short insertData = array[i];
            while (i > 0) {
                if (array[i - 1] > insertData) {
                    array[i] = array[i - 1];
                } else if (array[i - 1] < insertData) {
                    array[i] = insertData;
                    break;
                }
                i--;
            }
            if (i == 0) {
                array[0] = insertData;
            }
        }
        return array;
    }
    /**
     * 升序排序
     *
     * @param array
     * @return
     */
    public int[] ascengSort(int[] array) {
        int arrayLength = array.length;

        for (int i = 1; i < arrayLength; i++) {
            int insertData = array[i];
            while (i > 0) {
                if (array[i - 1] > insertData) {
                    array[i] = array[i - 1];
                } else if (array[i - 1] < insertData) {
                    array[i] = insertData;
                    break;
                }
                i--;
            }
            if (i == 0) {
                array[0] = insertData;
            }
        }
        return array;
    }
    /**
     * 升序排序
     *
     * @param array
     * @return
     */
    public long[] ascengSort(long[] array) {
        int arrayLength = array.length;

        for (int i = 1; i < arrayLength; i++) {
            long insertData = array[i];
            while (i > 0) {
                if (array[i - 1] > insertData) {
                    array[i] = array[i - 1];
                } else if (array[i - 1] < insertData) {
                    array[i] = insertData;
                    break;
                }
                i--;
            }
            if (i == 0) {
                array[0] = insertData;
            }
        }
        return array;
    }
    /**
     * 升序排序
     *
     * @param array
     * @return
     */
    public float[] ascengSort(float[] array) {
        int arrayLength = array.length;

        for (int i = 1; i < arrayLength; i++) {
            float insertData = array[i];
            while (i > 0) {
                if (array[i - 1] > insertData) {
                    array[i] = array[i - 1];
                } else if (array[i - 1] < insertData) {
                    array[i] = insertData;
                    break;
                }
                i--;
            }
            if (i == 0) {
                array[0] = insertData;
            }
        }
        return array;
    }
    /**
     * 升序排序
     *
     * @param array
     * @return
     */
    public double[] ascengSort(double[] array) {
        int arrayLength = array.length;

        for (int i = 1; i < arrayLength; i++) {
            double insertData = array[i];
            while (i > 0) {
                if (array[i - 1] > insertData) {
                    array[i] = array[i - 1];
                } else if (array[i - 1] < insertData) {
                    array[i] = insertData;
                    break;
                }
                i--;
            }
            if (i == 0) {
                array[0] = insertData;
            }
        }
        return array;
    }
    /**
     * 升序排序
     *
     * @param array
     * @return
     */
    public char[] ascengSort(char[] array) {
        int arrayLength = array.length;

        for (int i = 1; i < arrayLength; i++) {
            char insertData = array[i];
            while (i > 0) {
                if (array[i - 1] > insertData) {
                    array[i] = array[i - 1];
                } else if (array[i - 1] < insertData) {
                    array[i] = insertData;
                    break;
                }
                i--;
            }
            if (i == 0) {
                array[0] = insertData;
            }
        }
        return array;
    }

    /**
     * 降序排序
     *
     * @param array
     * @return
     */
    public byte[] dropSort(byte[] array) {
        int arrayLength = array.length;

        for (int i = 1; i < arrayLength; i++) {
            byte insertData = array[i];
            while (i > 0) {
                if (array[i - 1] < insertData) {
                    array[i] = array[i - 1];
                } else if (array[i - 1] > insertData) {
                    array[i] = insertData;
                    break;
                }
                i--;
            }
            if (i == 0) {
                array[0] = insertData;
            }
        }
        return array;
    }
    /**
     * 降序排序
     *
     * @param array
     * @return
     */
    public short[] dropSort(short[] array) {
        int arrayLength = array.length;

        for (int i = 1; i < arrayLength; i++) {
            short insertData = array[i];
            while (i > 0) {
                if (array[i - 1] < insertData) {
                    array[i] = array[i - 1];
                } else if (array[i - 1] > insertData) {
                    array[i] = insertData;
                    break;
                }
                i--;
            }
            if (i == 0) {
                array[0] = insertData;
            }
        }
        return array;
    }
    /**
     * 降序排序
     *
     * @param array
     * @return
     */
    public int[] dropSort(int[] array) {
        int arrayLength = array.length;

        for (int i = 1; i < arrayLength; i++) {
            int insertData = array[i];
            while (i > 0) {
                if (array[i - 1] < insertData) {
                    array[i] = array[i - 1];
                } else if (array[i - 1] > insertData) {
                    array[i] = insertData;
                    break;
                }
                i--;
            }
            if (i == 0) {
                array[0] = insertData;
            }
        }
        return array;
    }
    /**
     * 降序排序
     *
     * @param array
     * @return
     */
    public long[] dropSort(long[] array) {
        int arrayLength = array.length;

        for (int i = 1; i < arrayLength; i++) {
            long insertData = array[i];
            while (i > 0) {
                if (array[i - 1] < insertData) {
                    array[i] = array[i - 1];
                } else if (array[i - 1] > insertData) {
                    array[i] = insertData;
                    break;
                }
                i--;
            }
            if (i == 0) {
                array[0] = insertData;
            }
        }
        return array;
    }
    /**
     * 降序排序
     *
     * @param array
     * @return
     */
    public float[] dropSort(float[] array) {
        int arrayLength = array.length;

        for (int i = 1; i < arrayLength; i++) {
            float insertData = array[i];
            while (i > 0) {
                if (array[i - 1] < insertData) {
                    array[i] = array[i - 1];
                } else if (array[i - 1] > insertData) {
                    array[i] = insertData;
                    break;
                }
                i--;
            }
            if (i == 0) {
                array[0] = insertData;
            }
        }
        return array;
    }
    /**
     * 降序排序
     *
     * @param array
     * @return
     */
    public double[] dropSort(double[] array) {
        int arrayLength = array.length;

        for (int i = 1; i < arrayLength; i++) {
            double insertData = array[i];
            while (i > 0) {
                if (array[i - 1] < insertData) {
                    array[i] = array[i - 1];
                } else if (array[i - 1] > insertData) {
                    array[i] = insertData;
                    break;
                }
                i--;
            }
            if (i == 0) {
                array[0] = insertData;
            }
        }
        return array;
    }
    /**
     * 降序排序
     *
     * @param array
     * @return
     */
    public char[] dropSort(char[] array) {
        int arrayLength = array.length;

        for (int i = 1; i < arrayLength; i++) {
            char insertData = array[i];
            while (i > 0) {
                if (array[i - 1] < insertData) {
                    array[i] = array[i - 1];
                } else if (array[i - 1] > insertData) {
                    array[i] = insertData;
                    break;
                }
                i--;
            }
            if (i == 0) {
                array[0] = insertData;
            }
        }
        return array;
    }
}

//实例化
InsertSortUtils insertSort = new InsertSortUtils();

int类型升序测试

@Test
public void testInsertSort() {
    int[] a = {5, 3, 8, 1, 9, 23, 11, 6};
    System.out.println("排序前" + Arrays.toString(a));
    insertSort.ascengSort(a);
    System.out.println("排序后" + Arrays.toString(a));
}
测试结果

在这里插入图片描述

int类型降序测试

@Test
public void testInsertSort() {
    int[] a = {5, 3, 8, 1, 9, 23, 11, 6};
    System.out.println("排序前" + Arrays.toString(a));
    insertSort.dropSort(a);
    System.out.println("排序后" + Arrays.toString(a));
}
测试结果

在这里插入图片描述

char类型升序测试

@Test
public void testInsertSort() {
    char[] a = {'a','c','b','v','z','e','d'};
    System.out.println("排序前" + Arrays.toString(a));
    insertSort.ascengSort(a);
    System.out.println("排序后" + Arrays.toString(a));
}
测试结果

在这里插入图片描述

char类型降序测试

@Test
public void testInsertSort() {
    char[] a = {'a','c','b','v','z','e','d'};
    System.out.println("排序前" + Arrays.toString(a));
    insertSort.dropSort(a);
    System.out.println("排序后" + Arrays.toString(a));
}
测试结果

在这里插入图片描述

陆卿之
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构之插入排序
boy_of_god的博客
09-06 382
插入排序 1、将无序的序列插入到有序序列中 2、插入排序在什么情况下效率高 如果序列基本有序的情况下 插入排序的时候 数据序列比较少 插入 1、思想 排序过程：整个排序过程为n-1趟插入，即先将序列中第1个记录看成是一个有序子序列，然后从第2个记录开始，逐个进行插入，直至整个序列有序 实质：对线性表执行n-1次插入操作，只是先要找到插入位置 V[0], V[1...
详解Java常用排序算法-插入排序
08-26
Java排序算法 - 插入排序 插入排序（Insertion Sort）是一种简单的排序算法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增 1 的有序表。该算法的实现非常简单，但其时间复杂度...
插入排序
weixin_34117211的博客
04-23 73
插入排序是一种简单的类似于冒泡排序的方法。然而，数据交换次数呈线性化，相对比较稳定。 插入排序的基本思想是不断地将带排序的主键数据插入到有序的序列中，直到所有数据被排序。 原始数据使用随机函数生成。 采用结构化程序设计，可以很容易改为从标准输入或文件读入数据，只需要修改函数getData即可。 数据个数由宏定义给出，也可以轻松地改为输入。 /* * 插入排...
排序 -- 插入排序
qq_40337206的博客
04-22 365
插入排序模拟排序过程 图片（注：百度搜索而来的图片）链接: link. java代码实现 // An highlighted block public class InsertionSortTest { public static void sort(int[] arr, int n) { for (int i = 0; i < n; i++) { ...
基于python的排序算法-插入排序Insertion Sort
06-25
**插入排序(Insertion Sort)**是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到...
排序算法 -- 插入排序
04-21
**插入排序**是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。这种算法对大数据量的处理效率较低，但对于小规模数据或者部分有序的...
排序算法 - 直接插入排序（图文超详细）
最新发布
12-18
直接插入排序是一种基础且常用的排序算法，它的工作原理可以直观地理解为手动整理扑克牌的过程。在本篇文章中，我们将深入探讨直接插入排序的细节，包括它的基本思想、步骤、时间复杂度以及适用场景。 一、基本思想...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陆卿之

你的鼓励将是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值