Python - 深夜数据结构与算法之 ArrayList

大学生AI编程工作流:适配课程作业与竞赛的实战指南 AI编程工具正深刻改变计算机基础教学与工程实践的边界。从Python环境配置、VSCode开发调试,到智能车竞赛C语言寄存器操作、数学建模数据补全,其核心价值在于将模糊需求快速转化为可运行、可验证、可交付的代码。它不替代算法理解与系统思维,而是通过上下文感知补全、渐进式生成和本地化集成,显著压缩重复劳动耗时——尤其解决‘python安装’‘vscode配置python开发环境’等高频入门卡点,以及‘2025年电子设计竞赛电源题目解析’等强时效性工程任务。本文聚焦大学生真实学习场景,提供经校级竞赛与实验课验证 阅读详情

目录

一.引言

二.ArrayList 介绍

1.List

2.Linked List

3.Skip List

三.经典算法实战

1.Two-Sum [1]

2.Three-Sum [15]

3.Merge-Two-Sorted-List [21]

4.Remove-Duplicates-From-Sorted-Array [26]

5.Plus-One [66]

6.Rotate-Array [189]

7. Move-Zero [283]

四.总结


一.引言

本文介绍 Python 中的 ArrayList,主要表现形式为列表和链表,其在 Python 中表示为 []。

二.ArrayList 介绍

1.List

◆ 快速访问

每当我们申请创建数组时,计算机会为数组开辟一段连续的地址,每个地址可以通过内存管理器即上面的 Memory Controller 直接访问到,所以访问数组中任意一个元素的时间复杂度都是一样的,即 o(1),所以数组的访问速度非常快。

◆ 元素增删

增加元素最好的情况是从尾部 append,此时时间复杂度 o(1),最坏情况下插入到首位,需要挪动数组内全部元素,此时时间复杂度 o(n),平均下来需要挪动 n/2 个元素。

同理元素删除时也会有类似的时间复杂度,当把元素 Z 从数组中拿出去后,将 DEF 前移,此时将位置 6 置为 None,如果是 Java 会触发类似的垃圾回收机制,对空闲内存进行回收。

◆ 时间复杂度

ArrayList 具有 o(1) 的前后插入和查询的时间复杂度,但是插入和删除除首尾位置的元素,时间复杂度均为 o(n)。

2.Linked List

◆ 常见定义

# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

链表 Node 节点一般包含一个自身值 val 以及一个 next 指针指向其下一个元素,如果 next 为 None 代表没有后续的节点。

◆ 增加节点

链表增加节点只需将对应位置的 Node 的 next 指向 New Node,再将 New Node 的 next 指向原先的 next 节点,进行一次转换即可,操作的时间复杂度是 o(1)。

◆ 删除节点

与上面添加类似,只需将待删除的 Target Node 忽略,直接将前项的 Node 节点 next 指向后项的 Node 节点即可,其时间复杂度同样为 o(1)。

◆ 时间复杂度 

链表增删节点的时间复杂度均为 o(1),但是由于其连接的结构,要想访问链表中间位置的元素,需要一个 next 一个 next 访问,所以查询元素的复杂度为 o(n)。 

3.Skip List

◆ 基本性质

◆ 跳表形式

基于二分查找的思想,对于原始的元素有序的链表,我们可以添加一级索引,加速链表查询的步伐,假设我们查找 7,我们只需要在一级索引先查询,这时 1-4 本来需要 next.next 查询,而用第一级索引只需要 next 即可。随着索引层级的增多,我们查询的步伐也越来越大,其速度也越来越快,不过随之而来的是存储的增加,所以这也是一种空间换时间的经典算法思想。

◆ ​​​​​​​时间复杂度

由于是二分查找,随着每一层索引的增加,第 k 层对应的索引节点数就为 n / (2^k),层高 h 即为我们查找的时间复杂度,这里和前面介绍的 Trie 字典树也很像,我们只需要层高次查询即可查到对应的单词,即 o(logn)。

◆ ​​​​​​​空间复杂度

根据每 x 个节点抽取数据的不同,我们每层的节点数目也不相同,但是由于最上面的数列是收敛的,其计算下来空间复杂度仍然为 o(n),但是相比于前面的 List 和 Linked List,其实上面还是多了很多元素。

三.经典算法实战

上面我们介绍了 ArrayList 的几种表现形式以及其对应的一些特性,下面挑选一些 LeetCode 上比较经典的算法,加深 ArrayList 这个数据结构的印象和使用技巧。这里约定一下每个算法的表现形式,Two-Sum 代表算法名称,[x] 中括号里的 x 代表其对应 LeetCode 的第几题。

1.Two-Sum [1]

两数之和: ​​​​​​​https://leetcode.cn/problems/two-sum/description/

◆ ​​​​​​​题目分析

最最最基础的数组算法题,学计算机没做过 Two-Sum,就像考研英语没有背 Abandon 一样。针对本题,基本有两种思路。一种是直接两层 for 循环搞定,但是相对不够优雅;还有一种是借助 HashMap,通过空间辅助。

◆ ​​​​​​​双重循环

    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        length = len(nums)
        for i in range(length):
            for j in range(i + 1, length):
                if nums[i] + nums[j] == target:
                    return [i, j]
        return []

这里 i 遍历 range(length),j 遍历 range(i+1,length),其实就是枚举了数组中两两元素之间所有的可能,这里找到满足条件的 [i, j] 返回即可。时间复杂度 o(n^2),因为遍历了两轮数组,空间复杂度 o(1),没有使用额外的空间。

◆ ​​​​​​​HashMap 缓存

    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        m = {}
        
        for i in range(0, len(nums)):
            cur = target - nums[i]
            if (cur in m):
                return [m[cur], i]
            m[nums[i]] = i
        
        return []

m 用于缓存元素及其对应索引 index,我们只需要一层循环,由于 x + y = target,所以 y = target - x,针对每一个元素 x,我们只需要找 y 在不在 m 中,如果在的话返回二者索引即可,如果不在,则将当前元素缓存至 m 中。这里时间复杂度 o(n) 因为只 for 循环遍历了一次数组,空间复杂度也是 o(n),因为最差需要存储 n-1 个元素。

2.Three-Sum [15]

三数之和: https://leetcode.cn/problems/3sum/description/

◆ ​​​​​​​题目分析

两数之和、三数之和都是非常经典的算法题目,这里题目要求 i、j、k 三处的元素相加为 0。我们可以进行转换, nums[i] + nums[j] = -1 * nums[k],再令 -1 * nums[k] 为 Target,即可将题目转换为 Two-Sum,唯一区别是我们需要遍历多个 k 生成多个 Target,相当于做多次 Two-Sum。审题后我们大致得到下述信息:结果为不重复的三元组、a + b + c = 0 => a + b = -c。

◆ ​​​​​​​双指针

def threeSum(nums):
    result = []
    # 先将 nums 排序
    nums.sort()

    for k in range(len(nums) - 2):
        # 位置 k>0,则 k 后面的加起来必不可能为 0
        if nums[k] > 0:
            break

        # 排除两数相同的情况
        if k > 0 and nums[k] == nums[k - 1]:
            continue

        i, j = k + 1, len(nums) - 1

        while i < j:
            total = nums[i] + nums[j] + nums[k]

            if total < 0:
                i += 1
            elif total > 0:
                j -= 1
            else:
                # 排除左边、右边重复的情况
                result.append([nums[i], nums[j], nums[k]])
                while i < j and nums[i] == nums[i + 1]:
                    i += 1
                while i < j and nums[j] == nums[j - 1]:
                    j -= 1
                i += 1
                j -= 1
    return result

下面我们看下双指针的实现思路:

nums.sort() - 将数组排序后可以根据和的大小对左右指针进行移动

range(len(nums) - 2) - 因为是三元组,所以只需要遍历到倒数第 3 个元素即可

nums[k] > 0 - 因为数组有序,如果 k > 0,则 k 后面的三个元素怎么相加都可能为 0 

nums[k] == nums[k-1] -  target = nums[k] * 1,这里 continue 相当于实现了基于 target 的去重

while i < j - 左右指针进行夹逼法,如果满足 total = 0,则将 [i, j, k] 添加到 result 中

nums[i] == nums[i+1] - 这里相当于实现了基于三元组元素的去重

i += 1, j -= 1 - 完成一组解答后,继续遍历其他的 i,j 的情况 

Tips:

这里双指针的用法是 ArrayList 非常经典的算法,很多题目都可以借助双指针的思想,一定要好好掌握。 

3.Merge-Two-Sorted-List [21]

合并两个有序链表: https://leetcode.cn/problems/merge-tow-sorted-lists/

◆ ​​​​​​​题目分析

L1、L2 为给定的两个有序链表,需要将两个有序链表合成一个新的有序链表,思路比较好想但是实现起来需要一点技巧。这里需要构建一个新的 Node 节点,分别比较 L1 和 L2 的 head,将较小的节点连接到 Node,即 Node.next = Smaller,随后把 L1 或 L2 指向 next ,直到其中某个为空,再将剩下的节点补齐至最后即可。

◆ ​​​​​​​递归实现

    def mergeTwoLists(self, list1, list2):
        if not list1: return list2
        if not list2: return list1

        if list1.val <= list2.val:
            list1.next = self.mergeTwoLists(list1.next, list2)
            return list1
        else:
            list2.next = self.mergeTwoLists(list1, list2.next)
            return list2

这里开始的 not list1 和 not list2 用于检测链表为空的情况。后面判断大小也很好理解,博主当时有疑问的地方是 return list1,list2 这个部分,后来看了乐扣上网友的分析感觉很有道理:

递归的核心在于,我只关注我这一层要干什么,返回什么,至于我的下一层(规模减1),我不管,我就是甩手掌柜.

自己的理解:

结合这个图,针对最前面的 list,其只管返回自己即可,后面其余部分的链表合并可以看做是一个整体,和他没有关系,他甩手后面自己合并即可,但是他需要返回,因为这里不返回的话我们最终就没有最终输出结果了。

◆ ​​​​​​​从头再来

    def mergeTwoLists(self, l1, l2):
        cur = dummy = ListNode() # dummy 为影子节点

        while l1 and l2:
            # 判断数值并更新链表
            if l1.val > l2.val:
                cur.next = l2
                l2 = l2.next
            else:
                cur.next = l1
                l1 = l1.next

            cur = cur.next
        
        # 补齐剩下的有序链表   
        if l1:
            cur.next = l1
        if l2:
            cur.next = l2

        return dummy.next

这一版实现和我上面自己的思路分析比较一致,因为递归的思想有时候并不是很好想或者实现。这里 dummy 又称为影子节点,因为 cur 需要随着 while 循环逐步推进,这时候 cur 和 dummy 都指向同一个地址,我们后续想要获得头结点就只需要 dummy.next 即可,其主要是这个作用。whlie 和下面 if 的比较好理解,这一版是自己的思路实现,感觉更符合自己目前的水平哈哈。

​​​

4.Remove-Duplicates-From-Sorted-Array [26]

有序数组移除重复元素: https://leetcode.cn/problems/remove-duplicates-from-sorted-array

◆ ​​​​​​​题目分析

数组是非严格递增的,代表可能存在相同的元素。原地删除元素,代表我们不能引入额外的数据结构处理,例如引入 set 直接去重。最后是返回值,这里返回 nums 中非重复元素的数组长度而不是非重复元素。

◆ ​​​​​​​单指针

    def removeDuplicates(self, nums):

        # 长度为 1 直接返回
        if len(nums) == 1:
            return 1

        j = 0
        # 判重
        for i in range(len(nums)):
            if nums[i] != nums[j]:
                j += 1
                nums[j] = nums[i]

        return j + 1

引入单指针索引 j,遍历每个元素,如果其与上一个 j 对应的元素不相等,则 j += 1,放置新的非重复元素,最后由于数组索引是 0 开始,所以我们返回长度需要返回 j + 1。 

5.Plus-One [66]

数组元素加一: https://leetcode.cn/problems/plus-one/description/

◆ ​​​​​​​题目分析

这一题使用数组表示数字,将数字 +1 后再重新使用数组表示,数学逻辑的话很简单,就是一个加法,主要是其涉及到进位所以对于数组长度以及数组的索引元素会造成修改,所以我们主要进位导致的这两个问题即可。自己想了两个思路,一种是把数字 Int 直接提出来,加完再找新数组放进去;另外就是原地执行,通过一个辅助变量记录是否进位。

◆ ​​​​​​​直截了当

    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        
        num = ""
        for i in digits:
            num += str(i)

        plus = str(int(num) + 1) # 数组转数字 Int

        re = []
        for i in plus:
            re.append(int(i))

        return re

 这个方法是我读题第一时间想到的,执行起来看着还能接受,内存也没有消耗过大。

◆ ​​​​​​​原地起飞

    def plusOne(self, digits):

        length = len(digits)
        is_add = False # 记录是否进位
        for i in range(length):
            # 因为加法从个位开始,所以数组从后向前遍历
            cur_index = length - (i + 1)
            cur_value = digits[cur_index]

            if is_add or i == 0:
                cur_value = cur_value + 1
            
            # 判断是否需要进位    
            if cur_value >= 10:
                is_add = True
                digits[cur_index] = 0
            else:
                is_add = False
                digits[cur_index] = cur_value

        # 判断是否需要在数组前追加一位
        if is_add:
            return [1] + digits
        else:
            return digits

这个就是正常的加法逻辑,其通过 is_add 记录是否需要进位,随后从后向前没遍历一位都执行相加和修改元素,最后再判断一次 is_add 判断相加是否导致数字进位从而为数组补一位。由于是原地执行,所以内存的占用会比上面的方法小一些。

◆ ​​​​​​​二刷留念

class Solution(object):
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """

        add_num = 1

        for i in range(len(digits) - 1, -1, -1):
            cur = digits[i] + add_num

            if cur > 9:
                add_num = 1
                digits[i] = cur - 10
            else:
                add_num = 0
                digits[i] = cur
                break

        return [1] * add_num + digits

第二次刷本题,优化了执行的算法。

6.Rotate-Array [189]

轮转数组: https://leetcode.cn/problems/rotate-array/description/

 ◆ ​​​​​​​题目分析

根据 k 的步伐,数组后面的元素依次挤过来,前面的被顶到后边。以 [1,2,3,4,5,6,7] k=3 为例,挪动后的数组为 [5,6,7,1,2,3,4],所以 k 次移动对应的是 -k 即倒数 k 的元素对应的数组挪到前面,再把剩下的数组挪到后面。

 ◆ ​​​​​​​前后颠倒 - 错误版

    def rotate(self, nums, k):
        """
        Do not return anything, modify nums in-place instead.
        """
        if k == 0:
            return nums
        else:
            length = len(nums)
            move = k % length

            return nums[-move:] + nums[:-move]

这一版按照我们前面的思路写的,k % length 是为了防止数组轮转多遍。但是执行后会报错:

都是 "Do not return anything, modify nums in-place instead" 惹的祸,还是读题不严谨,而且题目要求原地修改,不允许修改内存地址。 

◆ ​​​​​​​前后颠倒 - 正确版

    def rotate(self, nums, k):
        """
        Do not return anything, modify nums in-place instead.
        """
        if k == 0:
            return nums
        else:
            length = len(nums)
            move = k % length

            nums[:] = nums[-move:] + nums[:-move]

这里去掉了 return,增加了 nums[:],[:] 的写法可以保持内存地址 id 不变,而 '=' 号后面的写法负责改变 value,这样就实现了数组轮转。

◆ 旋转跳跃

class Solution:

    # 数组对称交换
    def swap(self, nums, left, right):
        while left < right:
            nums[left], nums[right] = nums[right], nums[left]
            left += 1
            right -= 1
        
    # 换就完事了
    def rotate(self, nums, k):
        """
        Do not return anything, modify nums in-place instead.
        """
        if k == 0:
            return nums
        else:
            length = len(nums)
            k %= length
            self.swap(nums, 0, length-k-1)
            self.swap(nums, length-k, length-1)
            self.swap(nums, 0, length-1)

除了上面精简的写法外,还有一个 swap 的方法,其是根据元素对称性实现的,为了更好的理解代码,下面给出简单的执行过程,还是以 [1,2,3,4,5,6,7] k=3 为例: 

第一次 swap: [4,3,2,1,7,6,5] 反转前面 n-k 个

第二次 swap: [1,2,3,4,7,6,5] 反转后 k 个

第三次 swap: [5,6,7,1,2,3,4] 整体前后反转

多次 swap 执行时间较长,但是由于 swap 是原地交换,所以内存消耗较小。

7. Move-Zero [283]

移动零: https://leetcode.cn/problems/move-zeroes/description/

◆ 题目分析 

将所有零移动到数组后面,且不改变原始顺序,还是前面的思路方法,我们引入一个单指针,记录存放非0元素的位置,遇到为零的元素 i,将该元素与 j 交换,相当于把 0 扔后面,把非 0 拿到前面,再将 j += 1 指定下一个存放非 0 位置的元素即可。

◆ 斗转星移

class Solution(object):

    def swap(self, i, j, nums):
        nums[i], nums[j] = nums[j], nums[i]


    def moveZeroes(self, nums):
        """
        Do not return anything, modify nums in-place instead.
        """
        j = 0
        for i in range(len(nums)):
            if nums[i] != 0:
                self.swap(i, j, nums)
                j += 1

前面是数组的 swap,这个是直接 i、j 索引的 swap,遍历数组,判断非零元素并交换即可。以 [0,1,0,3,12] 为例:

i=1, j=0 => [1,0,0,3,12]

i=3, j=1 => [1,3,0,0,12]

i=4, j=2 => [1,3,12,0,0]

◆ 二刷留念

class Solution(object):

    def moveZeroes(self, nums):
        """
        Do not return anything, modify nums in-place instead.
        """

        position = 0

        for i in range(len(nums)):
            if nums[i] != 0:
                nums[position], nums[i] = nums[i], nums[position]
                position += 1
        
        return nums

不需要再向 swap 传参,这里直接原地操作即可。

四.总结

上面讲解了数组的基本概念以及 LeetCode 里一些基本的算法操作,这里介绍的题目以简单和中等为主,主要是用于了解一些常用的算法实现方式,这里数组和链表我们使用了:单指针、双指针、递归、元素 swap、数组 swap、空间换时间等最常用的技巧,后面可以多多练习加深印象,博主也会出其他数据结构的相关栏目。

本文都是工作之外的时间创作,大部分在晚上,所以其名为 <深夜数据结构与算法>,整理一篇文章大概需要两周左右,创作不易,如果对你有帮助,欢迎留下痕迹 ^_^

计算机专业现状分析:从劝退现象看行业挑战与个人应对策略 计算机科学作为一门基础学科,其核心在于通过算法、数据结构等原理解决复杂问题。随着技术快速迭代和行业需求变化,计算机专业面临着技术更新快、人才竞争激烈等现实挑战。从技术价值角度看,扎实的计算机基础能力依然是数字化转型时代的核心竞争力。在应用场景上,无论是软件开发、系统架构还是人工智能领域,都需要从业者具备持续学习和工程实践能力。本文围绕计算机专业学习路径、职业发展等话题,探讨如何应对行业变化,其中涉及技术迭代、结构性内卷等热词,为相关学习者提供参考。 阅读详情

相关推荐

C#性能真相:破除‘慢语言’认知误区与工程优化路径

编程语言性能并非绝对属性,而是依赖于运行时、应用场景与工程实践的综合体现。C#作为一门强类型、内存安全、支持异步和泛型的现代语言,其真实性能表现高度依赖.NET平台演进(如RyuJIT、Server GC、Span<T>)与开发者对底层机制的理解深度。将性能问题简单归因为‘C#慢’,往往混淆了语言语法、编译器优化、垃圾回收策略与IO模型等多层技术要素。在Web API、高并发服务及云原生场景中,ASP.NET Core凭借零分配序列化、高效异步调度与分代GC,已展现出优于PHP等传统脚本语言的实际吞吐能力。

405

【Python数据结构与算法】(二):数组列表(ArrayList)

数组列表是最常用的数据结构之一,本文介绍了数组列表和数组的基础知识,然后分别分析了python内置的list用法的时间复杂度。最后自己创建了一个list类

阿里云专家博主、数据科学领域优质创作者、统计er在读 3108

Python 列表list 数组array

Python 列表list 数组array

潜心 5455

ArrayList集合

对象数组 题目:定义一个数组,用来存储三个person对象(对象数组) 数组有一个缺点:一旦创建,程序运行期间长度不可以发生改变 任何数据类型都可以作为数组当中元素的类型(包括:基本类型,字符串,自定义的person类型等) 代码: 数组长度已确定为3,无法在程序运行期间再存储对象了。 package cn.luis.demo4; public class Demo01Array { public static void main(String[] args) { //

Luis 433

macOS 27下PlayCover“没有权限打开”的完整修复指南

macOS系统通过Gatekeeper、TCC(透明、同意与控制)和安全启动等机制,对第三方应用进行层层校验,以防范恶意代码。这些机制会检查应用的隔离属性、签名状态以及所需系统权限,当任一环节不满足时,就会出现“没有权限打开”的提示。对于开发者工具或未上架App Store的开源软件,这类拦截尤为常见。尤其在macOS 27上,系统进一步收紧了绕过策略,导致PlayCover等工具无法正常启动。本文以PlayCover为例,详细解析权限链路上的三道关卡,并给出清除隔离属性、调整SIP状态、重置TCC记录等完

weixin_32612263的博客 765

DDR4技术原理详解

DDR4是DDR4-SDRAM的简写,即第4代DDR-SDRAM,DDR-SDRAM全称Double Date Rate Synchronous Dynamic Random Access Memory。本文重点解析DDR4技术规范及其背后的电子电路原理,以及编程使用DDR4过程中需要注意的性能事项。

ctbinzi的专栏 1万+

Python学习之:Python 中的 list , array 的区别

文章目录listarray list list 是 python 中自带的数据结构,类似于 java 中的抽象数据结构“arraylist” ,其中可以存放各种数据类型的元素,即不限制 list 中的元素是否具有相同的数据类型 array python 中是不存在 array 这种数据结构的。 python 中的 array 是通过调用 numpy 库才能使用的 单维度的 list 可以直接通过 numpy.array() 转换成一维的 array,嵌套的list 也可以通过这个语句而直接转换成多维的 ar

qq_42902997的博客 1988

NC数据预处理避坑指南:从MATLAB读取到GeoTIFF导出,解决坐标翻转与值域异常

本文详细解析了NC数据预处理中的常见问题,包括MATLAB读取时的坐标翻转与GeoTIFF导出时的值域异常。通过实战案例,介绍了如何解决矩阵方向错乱、处理FillValue与scale_factor、精准移植空间参考等关键问题,帮助研究者高效完成气象数据的批量处理与GIS兼容性验证。

weixin_30788619的博客 656

学习笔记 | ArrayList的基本使用

Java:ArrayList的基本使用(学习笔记)

suweijie的博客 835

告别OLE!Delphi操作Excel的3种轻量级方案横向评测(FlexCel/XLSReadWriteII/LibXL)

本文深入评测了Delphi操作Excel的三种轻量级方案:FlexCel、XLSReadWriteII和LibXL。通过技术架构、API设计、性能测试和实战案例的全面对比,帮助开发者选择最适合的工具,提升Excel文件处理效率,告别传统OLE方案的依赖和性能问题。

onion的博客 934

WPS用户看过来:避开格式错乱坑,用WPS Office完美制作红头文件(2024最新版)

本文详细解析了WPS Office与Word在红头文件制作中的核心差异,提供了2024年最新版的零误差实战指南。从字体处理、页面布局到红头制作关键步骤,帮助用户避开格式错乱坑,确保跨设备显示一致。特别针对WPS用户优化,解决字体丢失、版式错位等常见问题。

weixin_26800111的博客 221

ArrayList 和 LinkedList 的区别

ArrayList 和 LinkedList 的区别

m0_58725148的博客 478

Ambari 安装部署教程(手把手教学)【超级详细】

本文为读者提供了一套超详细的 Apache Ambari 安装部署教程,采用手把手教学方式,适合初学者及大数据运维人员。内容涵盖前期准备、环境配置、Ambari Server 与 Agent 安装、集群初始化配置、常见问题排查等全流程操作,确保用户能够顺利搭建稳定的 Hadoop 大数据平台管理系统。

Five的博客 1万+

声明式编程与函数式思维:.NET开发者元能力升级指南

声明式编程是一种以‘做什么’(What)而非‘怎么做’(How)为核心的软件构造范式,其本质是通过抽象语法和领域特定语言(DSL)降低人类意图与机器执行之间的认知鸿沟。它依托函数式思维——如不可变性、纯函数、高阶操作——在C# LINQ、F# Actor模型及自定义内部DSL中落地;技术价值在于提升代码可读性、并发安全性与跨平台适配能力,广泛应用于高并发风控、实时流处理与医疗规则引擎等场景。本文结合Anders Hejlsberg经典趋势判断与.NET十二年工程实践,系统拆解如何将声明式理念转化为可测量、可

diaoqi6581的博客 500

华为OD机试真题 新系统2026-04-01 Java&Go 实现【勇攀数字高峰】

请你在给定的数字地形图中寻找登山路径,数字代表当前位置的海拔高度,要求从最低海拔出发,不断攀登,最终到达最高山峰。你需要寻找所有满足条件的登山路径。地图已经保证最低海拔和最高山峰都只有一个。

MISAYAONE的博客 629

ardupilot SBUS输入捕获

本节主要记录ardupilot 的sbus 输入捕获功能。ardupilot 默认支持多种无线协议控制输入设备,比如常用的PPM,SBUS,IBUS,DSM,SUMD,SRXL等协议,本节主要讲解ardupilot 如何通过定时器的pwm输入捕获来获取sbus数据。

陌城烟雨 272

编程入门的本质是认知重建,不是语法记忆

编程入门首先是一种计算思维的建立过程,其核心在于理解变量、函数、循环等基础概念背后的逻辑原理,而非机械记忆语法规则。从认知科学角度看,初学者常因工作记忆过载而陷入‘虚假掌握’——能复现代码却无法迁移应用。真正有效的学习路径需匹配人类认知规律:通过生活化类比建立概念锚点,借助可视化反馈强化神经联结,并以微型项目驱动渐进式能力构建。这种强调‘为什么’而非‘是什么’的教学范式,已在Python、JavaScript、TypeScript等现代语言教学中被反复验证。本文聚焦零基础学习者的认知断层与调试盲区,提供可落

didi9310的博客 350

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

leetcode加一(java)

原题如下 给定一个由整数组成的非空数组所表示的非负整数,在该数的基础上加一。 最高位数字存放在数组的首位, 数组中每个元素只存储单个数字。 你可以假设除了整数 0 之外,这个整数不会以零开头。 示例 1: 输入: [1,2,3] 输出: [1,2,4] 解释: 输入数组表示数字 123。 示例 2: 输入: [4,3,2,1] 输出: [4,3,2,2] 解释: 输入数组表示数字 4321。 来源...

zhuruihe2014的博客 187

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

集合ArrayList基本概念

集合用来保存一组数据 且长度不固定 ,声明集合时需要泛型。 JAVA库中带collection类,是除了Map外所有其他集合类的根接口。 包含了LIst 和 Set 还有Map 三种类型的集合。 ArrayList接口是一个允许元素重复的有序的接口, 在接口尾部添加一个元素的方法是add方法 add(“x")是添加x到元素尾部, add(a,"x")是添加x到下标a处(有可能出现下标越界情况) 集合A addall.(子集合) 是添加子集合的方法。 ...

m0_66605858的博客 267

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

ArrayList的size、内部数组的length和序列化及反序列化

前言: 抽时间看了一下ArrayList的代码,主要关注了它的序列化和反序列化这一块,因为这里有一个很有意思的点——用于保存数据的内部数组是使用transient修饰的。了解序列化知识的人都知道,如果一个变量被transient修饰的话,那么在序列化的时候它就会被忽略(当然了这里是针对Serialization这个接口),通常我们使用它来修饰一些我们不希望被序列化的数据,以达到保护的目的。但是,这里就会产生一个疑问,为什么ArrayList用于存储数据的内部数组elementData要使用transient

qq_40734247的博客 2802

list、array、arraylist三者的区别

数组array: 1、数组在内存中是连续存储的,所以它的索引速度非常快,而且赋值与修改元素也很简单。 2、在声明数组的时候必须指定数组的长度,数组的长度过长,会造成内存浪费,过短会造成数据溢出的错误。 3、只能存同一种类型,只能存一些比较基本的数值、字符类型,用得不是很多,一般用numpy里面的array,来做一些数值的处理。 4、可以通过索引值查找数据,但是能对整个数组进行数值运算 arrayl...

swan777的博客 1130

ArrayList集合中常用的方法

ArrayList相关方法简述List概念1.1 ArrayList常见方法1.1.1 构造器1.1.2 add 方法1.1.3 get和set方法1.1.4 contains 方法1.1.5 remove方法1.1.6 toArray方法1.1.7 asList方法 List概念 存储的元素有序、可重复,可以理解为存储对象的数组,是Connection的子接口,与数组相比,长度是可变的,可以动态的对集合中的数据进行增加或减少。有两个比较常见的实现类ArrayList与LinkedList,两个实现类的方法

上进的小仓鼠 1万+

python list常用方法_Python 列表 list 数组 array 常用操作集锦

Python中的列表(list)类似于C#中的可变数组(ArrayList),用于顺序存储结构。创建列表sample_list = ['a',1,('a','b')]Python 列表操作sample_list = ['a','b',0,1,3]得到列表中的某一个值value_start = sample_list[0]end_value = sample_list[-1]删除列表的第一个值del...

weixin_39890289的博客 590

java中如何选择合集,以及ArrayList 、LinkedList与python 的list用法对比

如何选择集合?* 在各种Lists中,最好的做法是以ArrayList作为缺省选择。当插入、删除频繁时,使用LinkedList();Vector总是比ArrayList慢,所以要尽量避免使用。* 在各种Sets中,HashSet通常优于TreeSet(插入、查找)。只有当需要产生一个经过排序的序列,才用TreeSet。TreeSet存在的唯一理由:能够维护其内元素的排序状态。* 在各种Maps中...

点滴记录,慢慢成长,一起分享 3928

Java的ArrayList与Python的list

Java Python3 增 boolean add(E e)在尾部增加一个元素 void add(int index, E e)在index处(0...n)增加一个元素 boolean addAll(Collection在尾部增加一个元素集合 boolean addAll(int index, Collection append(obj) -> None在尾

Elmo66的博客 4307

Python列表(list)的基本用法

列表(list)是最常用的Python数据类型,它可以作为一个方括号内的逗号分割值出现。 List中的数据项不需要具有相同的类型,可以进行的操作包括索引(第一个索引是0,第二个索引是1,以此类推)、切片、加、乘、检查成员等。 创建一个列表,只要把逗号分割的不同的数据项使用方括号括起来即可,如下所示: list1 = ['physics', 'chemistry', 1997, 2000] ...

小白_努力 15万+
上一篇: Python - 搭建 Flask 服务实现图像、视频修复需求
下一篇: LLM - 大模型速递之 Yi-34B 入门与 LoRA 微调
BIT_666
BIT_666 领域专家: 大数据技术领域 领域专家: 大数据技术领域
博客等级 码龄9年 8万+粉丝 496原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

BIT_666

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

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

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

打赏作者

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

抵扣说明:

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

余额充值