排序算法-插入排序 #算法学习

已于 2022-03-01 17:04:24 修改
阅读量196 收藏
点赞数
分类专栏： 学习 算法 文章标签： 算法 排序算法 go语言
于 2021-08-23 17:31:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36825982/article/details/119865069
版权

每日一题
Day1 兔子试毒 #每日一题
Day2 排序算法-插入排序 #每日一题
Day3 排序算法 #每日一题

Day2

题目引入

排序算法

最经典的算法之一
菜鸟教程这里罗列了十大经典排序算法，讲解的挺详细的，还有每种算法的单独讲解并配备了动图更好理解
以下就是教程中的冒泡算法图解
在这里插入图片描述

设计题目

排序算法是编程学习中接触最久的一种经典算法题，网上很多经典的算法和各种花式解法
所以我想分成几个步骤来慢慢的复习一下这个经典算法题

  1. 先用自己思路简单的实现排序
  2. 详细学习一下十大经典算法
  3. 重写(默写)十大算法
  4. 充分理解算法

开始学习

潦草的自编程序

第一次排序

package main
import (
    "fmt"
    "math/rand"
    "time"
)
func main() {
    start := time.Now().UnixNano()
    fmt.Printf("start: %v\n", start)
    defer func() {
        // 记录耗时
        end := time.Now().UnixNano()
        fmt.Printf("end: %v\nduration: %v\n", end, end-start)
    }()
    // 1 随机生成固定数组
    var arr []int
    // numsCount := 10
    numsCount := 100000
    for i := 0; i < numsCount; i++ {
        rand.Seed(int64(i))
        // rand.Seed(int64(time.Now().UnixNano()) + int64(i)) // 非固定
        arr = append(arr, rand.Intn(numsCount*10))
    }
    // 生成数组的时间为794828300 0.79秒
    fmt.Printf("排序前: %v ... %v\n", arr[:10], arr[len(arr)-10:])
    // 2 从小到大排序
    arr = arrSort(arr)
    fmt.Printf("排序后: %v ... %v\n", arr[:10], arr[len(arr)-10:])
}
// 2.1 用自己第一个思路做排序算法
func arrSort(arr []int) []int {
    for i, num := range arr {
        min := num
        minI := i
        for _i := i + 1; _i < len(arr); _i++ {
            if min > arr[_i] {
                min = arr[_i]
                minI = _i
            }
        }
        // 把最小的数放到第一位
        arr[minI] = arr[i]
        arr[i] = min
        // fmt.Printf("%v: %v\n", i, arr)
    }
    return arr
}

输出

start: 1629689102646758900
排序前: [793274 498081 266786 151008 636829 243626 651548 305886 697888 831901] ... [715529 760583 152069 297222 979203 168585 95815 653064 187794 350723]
排序后: [8 20 31 33 34 40 44 49 61 69] ... [999912 999938 999939 999947 999955 999957 999964 999984 999986 999994]
end: 1629689108024490800
duration: 5377731900

耗时5.3秒

第二次排序

func arrSort(arr []int) []int {
    for i := 1; i < len(arr); i++ {
        if arr[0] > arr[i] {
            num := arr[i]
            arr = append([]int{num}, (append(arr[:i], arr[i+1:]...))...)
        } else {
            for _i := 1; _i < i; _i++ {
                if arr[_i] > arr[i] {
                    num := arr[i]
                    var mNums = make([]int, len(arr[_i:i]))
                    copy(mNums, arr[_i:i])
                    arr = append(append(arr[:_i], num), (append(mNums, arr[i+1:]...))...)
                    break
                }
            }
        }
        // fmt.Printf("%v: %v\n", i, arr)
    }
    return arr
}

输出

start: 1629689520944933200
排序前: [793274 498081 266786 151008 636829 243626 651548 305886 697888 831901] ... [715529 760583 152069 297222 979203 168585 95815 653064 187794 350723]
排序后: [8 20 31 33 34 40 44 49 61 69] ... [999912 999938 999939 999947 999955 999957 999964 999984 999986 999994]
end: 1629689535714069200
duration: 14569136000

[崩溃]，一顿操作猛如虎，一看战绩14.5，还是乖乖先学习一下经典算法吧

学习十大经典算法

…

默写

插入排序

看了十大经典算法的插入算法后，我发现我的第二个思路跟插入算法有点相似，于是我试着跑了一下插入算法

func arrSort(arr []int) []int {
    for i := range arr {
        preIndex := i - 1
        current := arr[i]
        for preIndex >= 0 && arr[preIndex] > current {
            arr[preIndex+1] = arr[preIndex]
            preIndex -= 1
        }
        arr[preIndex+1] = current
    }
    return arr
}

输出

start: 1629690074829951700
排序前: [793274 498081 266786 151008 636829 243626 651548 305886 697888 831901] ... [715529 760583 152069 297222 979203 168585 95815 653064 187794 350723]
排序后: [8 20 31 33 34 40 44 49 61 69] ... [999912 999938 999939 999947 999955 999957 999964 999984 999986 999994]
end: 1629690076919296600
duration: 2089344900

2.08秒？啥？这是为什么？差距居然这么大

仔细观察一下自己的代码
以下逻辑看起来比较复杂，但是其实只有两步关键代码

  • s1 把最小的数插到第一位
  • s2 把遍历到的当前数插入到第二位与其之间
func arrSort(arr []int) []int {
	// 计算两步关键代码执行次数
    s1 := 0
    s2 := 0
	// 从数组的第二个开始遍历
    for i := 1; i < len(arr); i++ {
    	// 将当前的数与第一个数进行对比，如果第一个数大于当前数
        if arr[0] > arr[i] {
            s1++
        	// 则取出当前数
            num := arr[i]
            // 通过append方法将当前数放在数组第一位
            // 合并当前数之前的数和当前数之后的数而后放在第二位之后
            arr = append([]int{num}, (append(arr[:i], arr[i+1:]...))...)
        } else {
        	// 如果第一个数小于当前数，则从第二个数开始遍历与当前数对比
            for _i := 1; _i < i; _i++ {
            	// 如果但当前数小于第二个数与当前数之间的某个数则把当前数插入到这个数前面
                if arr[_i] > arr[i] {
                    s2++
                	// 取出当前数
                    num := arr[i]
                    // 准备一个新数组
                    var mNums = make([]int, len(arr[_i:i]))
                    // 取出这个数与当前数之间的数
                    copy(mNums, arr[_i:i])
                    // 保留这个数与之前的数的部分再把当前数插入到这后面
                    // 这个数与当前数之间的数拼接当前数之后的数
                    // 新的两部分再拼接到一起
                    arr = append(append(arr[:_i], num), (append(mNums, arr[i+1:]...))...)
                    break
                }
            }
        }
        // fmt.Printf("%v: %v\n", i, arr)
    }
    fmt.Printf("s1: %v s2: %v\n", s1, s2)
    return arr
}

输出

s1: 17 s2: 99971

插入排序
也可以分为两步关键代码

  • s1 把大于当前数的值往后移动一位
  • s2 把预先记录好的值插入到后移结束后的位置
func arrSort(arr []int) []int {
    s1 := 0
    s2 := 0
    for i := range arr {
        preIndex := i - 1
        current := arr[i]
        for preIndex >= 0 && arr[preIndex] > current {
            s1++
            arr[preIndex+1] = arr[preIndex]
            preIndex -= 1
        }
        s2++
        arr[preIndex+1] = current
    }
    fmt.Printf("s1: %v s2: %v\n", s1, s2)
    return arr
}

输出

s1: 2500603989 s2: 100000

可以看出插入排序的步骤执行的次数比我自己写的要多得多
可是实际执行的速度确是完全相反
我单独按照执行次数大致模拟执行了关键代码
我的代码

i := 100
for s1 :=0; s1 < 17; s1++ {
    num := arr[i]
    arr = append([]int{num}, (append(arr[:i], arr[i+1:]...))...)
}
_i := 50
for s2 := 0; s2 < 99971; s2++ {
    num := arr[i]
    var mNums = make([]int, len(arr[_i:i]))
    copy(mNums, arr[_i:i])
    arr = append(append(arr[:_i], num), (append(mNums, arr[i+1:]...))...)
}

耗时12.45秒
插入排序

for s1 := 0; s1 < 2500603989; s1++ {
    arr[preIndex+1] = arr[preIndex]
}
for s1 := 0; s1 < 100000; s1++ {
    arr[preIndex+1] = 10000
}

耗时2.07秒

到这里可以看得出来，我的算法虽然在操作数的步骤上节省了次数，但是所执行的代码效率却低很多

好吧，还是老老实实的先默写一遍经典的插入排序算法

func arrSort(arr []int) []int {
    for i := 1; i < len(arr); i++ {
        preIndex := i
        for j := i - 1; j >= 0; j-- {
            if arr[j] > arr[preIndex] {
            	// 在我上面的第一种排序中没用到这种互换的写法
            	// 后面在菜鸟教程的算法中学的[狗头]
                arr[preIndex], arr[j] = arr[j], arr[preIndex]
                preIndex--
            } else {
                break
            }
        }
    }
    return arr
}

输出

start: 1629704397774304200
排序前: [793274 498081 266786 151008 636829 243626 651548 305886 697888 831901] ... [715529 760583 152069 297222 979203 168585 95815 653064 187794 350723]
s1: 2500603989
排序后: [8 20 31 33 34 40 44 49 61 69] ... [999912 999938 999939 999947 999955 999957 999964 999984 999986 999994]
end: 1629704401410920900
duration: 3636616700

耗时3.6秒，还是比插入算法慢
这次默写是在我在分析自己写的算法与插入排序算法之前写的
现在可以初步猜测我默写的算法中与插入算法的区别在于

  1. 插入算法是把当前数取出来前面的数在特定条件下往后移一位，后移结束再把预先取出的值插入到指定位置
  2. 我默写的算法则是每次都做一次前后数互换，虽然不需要后移结束后再做插入。但是显然这种互换操作应该是比只做后移效率要低

用同样的方式测试一下

j := 100
preIndex:= 99
for s1 := 0; s1 < 2500603989; s1++ {
    arr[preIndex], arr[j] = arr[j], arr[preIndex]
}

耗时3.6秒，果然

重新默写

func arrSort(arr []int) []int {
    for i, current := range arr {
        preIndex := i - 1
        for ; preIndex >= 0 && arr[preIndex] > current; preIndex-- {
            arr[preIndex+1] = arr[preIndex]
        }
        arr[preIndex+1] = current
    }
    return arr
}

基本一致
最后再用其他语言加深一下印象

// javascript
const arrSort = (arr) => {
    for (let i in arr) {
        let preIndex = i - 1
        const current = arr[i]
        for (; preIndex>=0 && arr[preIndex] > current; preIndex--) {
            arr[preIndex+1] = arr[preIndex]
        }
        arr[preIndex+1] = current
    }
    return arr
}

// php
function arrSort($arr) {
    foreach ($arr as $i => $current) {
        $preIndex = $i - 1;
        for (; $preIndex >= 0 && $arr[$preIndex] > $current; $preIndex--) {
            $arr[$preIndex+1] = $arr[$preIndex];
        }
        $arr[$preIndex+1] = $current;
    }
    return $arr;
}

-- lua
function arrSort(arr)
    for i,current in ipairs(arr) do
        local preIndex = i-1
        while (preIndex >= 1 and arr[preIndex] > current) do
            arr[preIndex+1] = arr[preIndex]
            preIndex = preIndex - 1
        end
        arr[preIndex+1] = current
    end
    return arr
end

# python
def arrSort(arr):
    for i in range(len(arr)):
        preIndex = i - 1
        current = arr[i]
        while preIndex >= 0 and arr[preIndex] > current:
            arr[preIndex+1] = arr[preIndex]
            preIndex -= 1
        arr[preIndex+1] = current
    return arr

Day3见

[捂脸]，搞这么久，后面的排序算法还是留到Day3吧

半本说明书
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
菜鸟学JAVA之——插入排序
菜鸟琪
11-03 352
插入排序 首先模拟一个场景便于理解： 有5个人需要按从小到大的身高依次排序。首先，第二个人与他前面的那个人比较，如果他比前面的那个人低，那么两人互换位置，否则不换，这两个人就排好了序。然后第三个人与第二个人比较身高，如果三号同学比二号同学低，那么三号与二号换位置，然后三号在与一号比，低的向前站，否则（第三个人比第二个人高），位置不变，继续排第四个人，这时，前三个人的顺序就排好了，接下来一次按照这个...
Java菜鸟教程 插入排序初步和几个有趣的练习
thomasli2017的博客
08-24 532
最近，笔者学习了插入排序，并做了几个java的练习，在此分享一下。 插入排序：         插入排序就跟扑克牌码牌一样，每一个数字与先前的数字比较，然后插入到适当的位置，这样依次进行，从而从小到大（或从大到小）排序。它与冒泡排序不同的地方在于，冒泡排序是一个数与数组中所有数字进行比较，而插入排序则是一个数字i[j]与i[0]   i[1]  i[2]   ………… i[j-1] 进行比较。
插入排序 -- 菜鸟练习
m0_67458511的博客
01-10 127
插入排序 -- 菜鸟练习
菜鸟笔记--插入排序
chickendaddy的博客
04-10 91
def insert_sort(alist): len(alist)=n for j in range(1,n): i=j while i>0: if alist[i]<alist[i-1]: alist[i], alist[i-1] = alist[i-1], alist[i] i -=1 else: break
插入排序排序php,php插入排序法实现数组排序实例
weixin_42190030的博客
03-11 153
本文实例讲述了php插入排序法实现数组排序的方法。分享给大家供大家参考。具体分析如下：插入排序法的基本思路：同样以案例来说明，还是以$arr = array(2,6,3,9)，由大到小排序。实现原理：假设(并不实际创建)有一个有序数组$arr = array(2)，用$arr[1]=6来与它进行比较，如果6>2，由把$arr[0]后移到$arr[1]位置，而6插入到$arr[0]位置。接着，...
C语言练习之排序算法：插入排序
01-16
在初学C语言时，比较重要的知识点就是排序算法，这里提供了一种插入排序算法的实现路径，供广大学习者参考。
使用Java与Python十大排序算法之直接插入排序
最新发布
01-31
直接插入排序 前面文章已经讲完了交换类排序，接下来开始学习插入类排序。顾名思义，所谓插入排序指我们会为每一个数据安排一个适合它的位置并将其插入，直到所有数据就位则排序完成。 直接插入法便是插入排序的典型...
Python实现的直接插入排序算法示例
09-20
以下是Python实现的直接插入排序算法的详细解释： ```python # -*- coding:utf-8 -*- '''直接插入的python实现 时间复杂度O(n^2) 空间复杂度O(1) 稳定思想：先将前两个元素排序，第三个元素插入前面已排好序列，...
Go语言排序算法之插入排序与生成随机数详解
01-01
这里跟大家一起分享golang实现一些排序算法，并且说明如何生成随机数。下面话不多说了，来一起看看详细的介绍吧。 经典排序算法 算法的学习非常重要，是检验一个程序员水平的重要标准。学习算法不能死记硬背，需要...
排序算法（三） 插入排序
CrazyApes的博客
06-08 456
这是数学 本文：https://www.jianshu.com/p/d31cb21342ed 插入排序 (Insertion sort) 插入排序，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法。插入排序是指在待排序的元素中，假设前面n-1(其中n>=2)个数已经是排好顺序的，现将第n个数插到前面已经排好的序列中，然后找到合适自己的位置，使得插入第n个数的这个序列也是排好顺序的。按照此法对所有元素进行插入，直到整个序列排为有序的过程，称为插入排序。插入排序是一种最简单的排序方法。.
php数组排序插入法,php插入排序法实现数组排序实例
weixin_33277243的博客
03-12 208
本文实例讲述了php插入排序法实现数组排序的方法。分享给大家供大家参考。具体分析如下：插入排序法的基本思路：同样以案例来说明，还是以$arr = array(2,6,3,9)，由大到小排序。实现原理：假设(并不实际创建)有一个有序数组$arr = array(2)，用$arr[1]=6来与它进行比较，如果6>2，由把$arr[0]后移到$arr[1]位置，而6插入到$arr[0]位置。接着，...
归并排序执行次数_快速排序-插入排序-归并排序
weixin_39693950的博客
12-09 202
快速排序算法快速排序的思想代码实现import java.util.Arrays; public class QuickSort { public static void main(String[] args){ QuickSort quickSort = new QuickSort(); int arr[] = {4, 6, 1, 2, 9, 0, 3...
一维数组，插入排序法
m0_67841161的博客
02-13 398
一维数组排序，插入排序法
直接插入排序（Straight Insertion Sort）
Aspect of Twilight的博客
11-15 1409
一、基本思想 直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。 实际中我们玩扑克牌时，就用了插入排序的思想 当我们摸到7这张牌时，怎样插入可以得到新的有序牌组呢？ 我们先拿7从后往前依次作比较（之前插的牌已经有序），直到遇到小于等于7的数字（牌5），然后我们将7插入到该数字（牌5）后面，这样我们得到的牌组依然是有序的，这就是我们生活中常见的直接插入排序。 因此简洁来说，插.
JavaScript-冒泡排序、选择排序、插入排序
qq_57443373的博客
09-27 296
今天学习一下算法 文章目录一、冒泡排序二、选择排序三、插入排序 一、冒泡排序 算法思想： 以升序排序为例，即最小的数在前 对数组进行一次遍历，如果相邻的两个数，前面的比后面的大，则交换他们的位置。 第一次遍历会将最大的数字排到最后的位置 第二次遍历会将第二大的数字排到倒数第二的位置 以此类推，遍历n-1次后，整个数组就有序了。 引用一下菜鸟教程的图片,很形象的描绘了冒泡排序的思想。 来看代码 const sort=(arr)=>{ let result=[...arr]; let te.
冒泡排序、插入排序、选择排序的时间、空间复杂度以及优化方案
何冽冽的博客
10-04 1333
冒泡排序、插入排序、选择排序的时间复杂度、优化以及是否稳定问题
排序算法—插入排序（含C语言代码示例）
weixin_52185996的博客
09-18 9846
插入算法作为几大经典的排序算法之一，它的性能在其中算是比较不错的了（主要是稳定）；插入算法的基本原理就是在一串乱序的数字中，首先认为第一个数是有序的，然后从第二个数开始比较，每次比较都与前面排好序的部分由后往前进行比较；比如第二个数和第一个数比较，然后第三个数和先和第二个数比较然后在和第一个数比较，第四个数先和第三个数比较然后再分别和第二、第一个数比较。如果在比较的过程中遇到的后一个数比自己大而前一个数比自己小那么就把自己插入到这两个数之间，然后结束这一轮排序进入下一轮；
C语言排序方法-----直接插入排序
HXYDJ的博客
03-30 4744
插入排序的基本思想是：每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。 插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序， 下面直接看C代码的实现： void insertSort( int num[], int cou...
直接插入排序比较次数_算法排序----插入排序法
weixin_39594312的博客
01-27 7302
接下来我来讲述一下插入排序法。首先来解释一下插入排序法的原理，它的原理是每插入一个数都要将它和之前的已经完成排序的序列进行重新排序，也就是要找到新插入的数对应原序列中的位置。那么也就是说，每次插入一个数都要对原来排序好的那部分序列进行重新的排序，时间复杂度同样为O(n²)。 这种算法是稳定的排序方法。直接插入排序算法分析根据代码我们来解释一下直接插入排序的核心例如，我们要对5,3,4,6,2这几个...
排序算法集成课设说明书.docx
12-26
首先介绍了常见的几种排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。然后对每种排序算法进行了详细的分析，包括时间复杂度、空间复杂度、稳定性等方面的比较。接着对每种排序算法进行了具体的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值