排序算法之插入排序

简介: 排序算法之插入排序

1 算法描述

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

2 算法实现

分解1:从未排序数组中取出第一个元素,和已排序的集合中的元素进行比较,则将被比较的元素向后移动.直到数组的头部或者找到比前面的比取出的元素要小的位置。

  int[] arrs = { 8, 6, 1, 7, 2, 5, 4, 12, 9 };
      //获取未排序数组的第一个数组
      int insert  = arrs[1];
      //判断大小
      if(arrs[0]>insert) {
          //如果大则向后移动
          arrs[1] = arrs[0];
      }
      //找到出入的位置进行插入
      arrs[0] = insert;
      ///输出结果
      for (int i = 0; i < arrs.length; i++) {
          System.out.print(arrs[i]+",");
      }

分解2:重复分解1的操作,逐步扩展已排序好队列。

int[] arrs = { 8, 6, 1, 7, 2, 5, 4, 12, 9 };
      ///
      第一轮插入
      //获取未排序数组的第一个数组
      int insert  = arrs[1];
      //判断大小
      if(arrs[0]>insert) {
          //如果大则向后移动
          arrs[1] = arrs[0];
      }
      //找到出入的位置进行插入
      arrs[0] = insert;
      // 6, 8, 1, 7, 2, 5, 4, 12, 9
      ///
      第二轮插入
      insert  = arrs[2];
      //判断大小
      if(arrs[1]>insert) {
          //如果大则向后移动
          arrs[2] = arrs[1];
          //      1
          // 6, 8, 8 , 7, 2, 5, 4, 12, 9
      }
      if(arrs[0]>insert) {
          //如果大则向后移动
          arrs[1] = arrs[0];
          // 1      
          // 6, 6, 8 , 7, 2, 5, 4, 12, 9
      }
      // 1, 6, 8 , 7, 2, 5, 4, 12, 9
      //找到出入的位置进行插入
      arrs[0] = insert;
      ///
      ///第三轮插入
      insert  = arrs[3];
      //判断大小
      if(arrs[2]>insert) {
          //如果大则向后移动
          arrs[3] = arrs[2];
          //       7
          // 1, 6, 8 , 8, 2, 5, 4, 12, 9
      }
      if(arrs[1]>insert) {
          //如果大则向后移动
          arrs[2] = arrs[1];
      }else {
          //如果遇到前面的数字比插入的元素小,直接插入
          arrs[2] = insert;
          // 1, 6, 7 , 8, 2, 5, 4, 12, 9
      }
      ///输出结果
      for (int i = 0; i < arrs.length; i++) {
          System.out.print(arrs[i]+",");
      }

分解3:使用循环操作优化每一轮寻找插入位置的操作

int[] arrs = { 8, 6, 1, 7, 2, 5, 4, 12, 9 };
        ///
        第一轮插入
        int start = 1;
        //获取未排序数组的第一个数组
        int insert  = arrs[start];
        while(start>0) {
            //判断大小
            if(arrs[start-1]>insert) {
                //如果大则向后移动
                arrs[start] = arrs[start-1];
            }else {
                //如果小于insert的话,就是插入的位置
                arrs[start] = insert;
                break; //循环中止
            }
            start --;
        }
        if(start==0) {
            arrs[0] = insert;
        }

        // 6, 8, 1, 7, 2, 5, 4, 12, 9
        ///
        第二轮插入
        start = 2;
        insert  = arrs[start];
        while(start>0) {
            //判断大小
            if(arrs[start-1]>insert) {
                //如果大则向后移动
                arrs[start] = arrs[start-1];
            }else {
                //如果小于insert的话,就是插入的位置
                arrs[start] = insert;
                break; //循环中止
            }
            start --;
        }
        if(start==0) {
            arrs[0] = insert;
        }
        ///
        ///第三轮插入
        start = 3;

        insert  = arrs[start];

        while(start>0) {
            //判断大小
            if(arrs[start-1]>insert) {
                //如果大则向后移动
                arrs[start] = arrs[start-1];
            }else {
                //如果小于insert的话,就是插入的位置
                arrs[start] = insert;
                break; //循环中止
            }
            start --;
        }
        if(start==0) {
            arrs[0] = insert;
        }
        ///输出结果
        for (int i = 0; i < arrs.length; i++) {
            System.out.print(arrs[i]+",");
        }

分解4:使用循环操作优化多轮的插入操作

 int[] arrs = { 8, 6, 1, 7, 2, 5, 4, 12, 9 };
        ///
        第一轮插入
        for (int start = 1; start < arrs.length; start++) {
            //获取未排序数组的第一个数组
            int insert  = arrs[start];
            while(start>0) {
                //判断大小
                if(arrs[start-1]>insert) {
                    //如果大则向后移动
                    arrs[start] = arrs[start-1];
                }else {
                    //如果小于insert的话,就是插入的位置
                    arrs[start] = insert;
                    break; //循环中止
                }
                start --;
            }
            //如果是首位置,就直接插入
            if(start==0) {
                arrs[0] = insert;
            }
        }
        ///输出结果
        for (int i = 0; i < arrs.length; i++) {
            System.out.print(arrs[i]+",");
        }

插入排序的交换次数多,但是循环比较的次数少

目录
相关文章
|
2月前
|
算法 搜索推荐 C#
|
3月前
|
机器学习/深度学习 算法 搜索推荐
数据结构算法--2 冒泡排序,选择排序,插入排序
**基础排序算法包括冒泡排序、选择排序和插入排序。冒泡排序通过相邻元素比较交换,逐步将最大值“冒”到末尾,平均时间复杂度为O(n^2)。选择排序每次找到剩余部分的最小值与未排序部分的第一个元素交换,同样具有O(n^2)的时间复杂度。插入排序则类似玩牌,将新元素插入到已排序部分的正确位置,也是O(n^2)复杂度。这些算法适用于小规模或部分有序的数据。**
|
3月前
|
算法 搜索推荐
数据结构与算法-插入排序
数据结构与算法-插入排序
25 2
|
3月前
|
算法 搜索推荐 数据可视化
【漫画算法】插入排序:插入宝石的传说
【漫画算法】插入排序:插入宝石的传说
|
3月前
|
人工智能 搜索推荐 JavaScript
心得经验总结:排序算法:插入排序法(直接插入法和希尔排序法)
心得经验总结:排序算法:插入排序法(直接插入法和希尔排序法)
24 0
|
3月前
|
机器学习/深度学习 搜索推荐 算法
【C/排序算法】:直接插入排序和希尔排序
【C/排序算法】:直接插入排序和希尔排序
28 0
|
3月前
|
搜索推荐
排序算法---插入排序-----详解&&代码
排序算法---插入排序-----详解&&代码
|
3月前
|
人工智能 算法 C语言
数据结构与算法——简单排序-冒泡排序、插入排序,时间复杂度下界(图示、代码、时间复杂度、定理)
数据结构与算法——简单排序-冒泡排序、插入排序,时间复杂度下界(图示、代码、时间复杂度、定理)
31 0
|
4月前
|
存储 算法 搜索推荐
【数据结构与算法】:插入排序与希尔排序
欢迎大家来到初阶数据结构的最后一小节:排序
【数据结构与算法】:插入排序与希尔排序
|
4月前
|
搜索推荐 算法 Java
sort-05-insert sort 插入排序算法详解
这是一个关于排序算法的系列文章总结,包括冒泡排序、快速排序、选择排序、堆排序、插入排序等10种排序算法的详细讲解和Java实现。插入排序是一种简单直观的排序算法,通过构建有序序列并逐个插入新元素来排序。提供的Java代码展示了插入排序的实现过程,并附有测试示例。所有算法已开源在GitHub项目[https://github.com/houbb/sort](https://github.com/houbb/sort)中。